diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 01a88897c..1324171c8 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -1,4 +1,4 @@ -# Ci related folders +# CI related resources /.github/ @weaviate/core decrypt_secret.sh @weaviate/core secrets.tar.gp @weaviate/core diff --git a/.github/workflows/create-release.yaml b/.github/workflows/create-release.yaml index 6c8824031..82aad7758 100644 --- a/.github/workflows/create-release.yaml +++ b/.github/workflows/create-release.yaml @@ -1,17 +1,22 @@ name: Create Release on: push: - # run only on tags tags: - '**' + pull_request: + # Release a new SNAPSHOT version every time a PR is merged to v6. + types: [closed] + branches: ['v6'] jobs: release: name: Deploy - if: startsWith(github.ref, 'refs/tags') + if: > + (github.event_name == 'push' && startsWith(github.ref, 'refs/tags')) + || (github.event_name == 'pull_request' && github.event.pull_request.merged == true) runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Unpack secrets env: GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} @@ -39,7 +44,7 @@ jobs: retention-days: 1 gh-release: name: Create a GitHub Release - if: startsWith(github.ref, 'refs/tags') + if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') runs-on: ubuntu-latest needs: [ release ] steps: diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index b68731aa5..cdcf934fc 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -4,27 +4,118 @@ on: branches: - main pull_request: +concurrency: + group: tests-${{ github.ref }} + cancel-in-progress: true + +env: + IMG2VEC: cr.weaviate.io/semitechnologies/img2vec-pytorch:resnet50 + MINIO: minio/minio + MODEL2VEC: cr.weaviate.io/semitechnologies/model2vec-inference:minishlab-potion-base-4M + DOCKER_IMAGES_TAR: docker-images.tar jobs: - tests: - name: Tests + docker-cache: + name: Cache shared Docker images runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - name: Login to Docker Hub - if: ${{ !github.event.pull_request.head.repo.fork }} - uses: docker/login-action@v2 - with: - username: ${{secrets.DOCKER_USERNAME}} - password: ${{secrets.DOCKER_PASSWORD}} - - name: Run Build - run: mvn -DskipTests clean package - - name: Run Tests - env: - OKTA_DUMMY_CI_PW: ${{ secrets.OKTA_DUMMY_CI_PW }} - WCS_DUMMY_CI_PW: ${{ secrets.WCS_DUMMY_CI_PW }} - OKTA_CLIENT_SECRET: ${{ secrets.OKTA_CLIENT_SECRET }} - AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }} - OPENAI_APIKEY: ${{ secrets.OPENAI_APIKEY }} - run: | - mvn clean test + - name: Login to Docker Hub + if: ${{ !github.event.pull_request.head.repo.fork }} + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + - id: cache-check + uses: actions/cache/restore@v4 + env: + DOCKER_CACHE_KEY: docker-images-${{ env.IMG2VEC }}-${{ env.MINIO }}-${{ env.MODEL2VEC }} + with: + path: ${{ env.DOCKER_IMAGES_TAR }} + key: ${{ env.DOCKER_CACHE_KEY }} + lookup-only: true # Only check if cache exists, don't download + - name: Free Disk Space (Ubuntu) + uses: jlumbroso/free-disk-space@v1.3.1 + with: + tool-cache: false + android: true + dotnet: true + haskell: true + large-packages: true + docker-images: false + swap-storage: false + - name: Pull images + if: steps.cache-check.outputs.cache-hit != 'true' + run: | + docker pull $IMG2VEC + docker pull $MINIO + # docker pull $MODEL2VEC + docker save $IMG2VEC $MINIO -o $DOCKER_IMAGES_TAR + - name: Cache images + if: steps.cache-check.outputs.cache-hit != 'true' + uses: actions/cache/save@v4 + env: + DOCKER_CACHE_KEY: docker-images-${{ env.IMG2VEC }}-${{ env.MINIO }}-${{ env.MODEL2VEC }} + with: + path: ${{ env.DOCKER_IMAGES_TAR }} + key: ${{ env.DOCKER_CACHE_KEY }} + + maven-cache: + name: Cache Maven dependencies + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-java@v4 + with: + distribution: "zulu" + java-version: "17" + cache: "maven" + - run: mvn dependency:go-offline + + test: + name: Test + runs-on: ubuntu-latest + needs: [docker-cache, maven-cache] + strategy: + fail-fast: false + matrix: + WEAVIATE_VERSION: ["1.32.24", "1.33.11", "1.34.7", "1.35.2"] + steps: + - uses: actions/checkout@v4 + + - uses: actions/cache/restore@v4 + env: + DOCKER_CACHE_KEY: docker-images-${{ env.IMG2VEC }}-${{ env.MINIO }}-${{ env.MODEL2VEC }} + with: + path: ${{ env.DOCKER_IMAGES_TAR }} + key: ${{ env.DOCKER_CACHE_KEY }} + - name: Free Disk Space (Ubuntu) + uses: jlumbroso/free-disk-space@v1.3.1 + with: + tool-cache: false + android: true + dotnet: true + haskell: true + large-packages: true + docker-images: false + swap-storage: false + - name: Load Docker images + run: | + if [ -f $DOCKER_IMAGES_TAR ]; then + docker load -i $DOCKER_IMAGES_TAR + fi + - uses: actions/setup-java@v4 + name: Setup JDK + with: + distribution: "zulu" + java-version: "17" + cache: "maven" + + - name: Run Tests (v${{ matrix.WEAVIATE_VERSION }}) + env: + OKTA_DUMMY_CI_PW: ${{ secrets.OKTA_DUMMY_CI_PW }} + WCS_DUMMY_CI_PW: ${{ secrets.WCS_DUMMY_CI_PW }} + OKTA_CLIENT_SECRET: ${{ secrets.OKTA_CLIENT_SECRET }} + AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }} + OPENAI_APIKEY: ${{ secrets.OPENAI_APIKEY }} + WEAVIATE_VERSION: ${{ matrix.WEAVIATE_VERSION }} + run: mvn verify -Dgpg.skip diff --git a/.gitignore b/.gitignore index 052460830..ee565b6c5 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ target/ # maven-lombok-plugin .factorypath +# Surefire statistics for optimized execution time +.surefire-* diff --git a/CONTRIBUTE.md b/CONTRIBUTE.md index 0a3a8f385..b913d2582 100644 --- a/CONTRIBUTE.md +++ b/CONTRIBUTE.md @@ -2,7 +2,7 @@ Contributing works pretty easy. You can do a pull request or you can commit if you are part of a Weaviate team. ### Code of Conduct -Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. +Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md) @@ -27,6 +27,22 @@ AKA: smart commits If you create a pull request without smart commits, the pull request will be [squashed into](https://blog.github.com/2016-04-01-squash-your-commits/) one git commit. +### Updating dependencies + +It's a good practice to periodically check for possible dependency upgrades. Ideally, we should do it before every release. + +```sh +mvn versions:display-property-updates +``` + +If appropriate, update dependency version with this command: + +```sh +mvn versions:update-properties +``` + +Commit all version upgrades in a single commit, unless there's a good reason not to. + ### Contributor License Agreement Contributions to Weaviate Java client must be accompanied by a Contributor License Agreement. You (or your employer) retain the copyright to your contribution; this simply gives us permission to use and redistribute your contributions as part of Weaviate Java client. Go to [this page](https://weaviate.io/service/contributor-license-agreement) to read the current agreement. diff --git a/README.md b/README.md index c90984d4c..bcb1c4b4c 100644 --- a/README.md +++ b/README.md @@ -1,38 +1,62 @@ -# Weaviate Java client Weaviate logo +# Weaviate Java client Weaviate logo -A Java native client for Weaviate. - -## ⚠️ New Java client version ⚠️ +[![Build Status](https://github.com/weaviate/java-client/actions/workflows/.github/workflows/test.yaml/badge.svg?branch=main)](https://github.com/weaviate/java-client/actions/workflows/.github/workflows/test.yaml) -The **Weaviate Java Client v6** is now available and should be used for all new projects: +Official Weaviate Java Client. -- **[Switch to v6 branch](https://github.com/weaviate/java-client/tree/v6)** +> [!IMPORTANT] +> `client6` does not support many of the legacy features supported in other clients. Ensure your instance is running at least `v1.32` to avoid compatibility issues. -**The v5 client is now deprecated** and will not receive updates for new Weaviate features. We strongly recommend migrating to v6 to access the latest capabilities and improvements. +## Usage ---- +To start using Weaviate Java Client add the dependency to `pom.xml`: -## Usage (v5 - Deprecated) +```xml + + io.weaviate + client6 + 6.0.1 + +``` -> **Note:** The information below is for the deprecated v5 client. Please use v6 for new projects. +### Uber JAR🫙 -To start using Weaviate Java client v5, add this dependency to `pom.xml`: +If you're building a uber-JAR with something like `maven-assembly-plugin`, use a shaded version with classifier `all`. +This ensures that all dynamically-loaded dependecies of `io.grpc` are resolved correctly. ```xml - io.weaviate - client - 5.6.0 + client6 + 6.0.1 + all ``` -### For applications on Java 9 or above +### SNAPSHOT releases + +The latest development version of `client6` is released after every merged pull request. To include it in you project set the version to `6.0.0-SNAPSHOT` and [configure your `` section accordingly](https://central.sonatype.org/publish/publish-portal-snapshots/#consuming-snapshot-releases-for-your-project). +Please be mindful of the fact that this is not a stable release and breaking changes may be introduced. -The client utilizes Gson for JSON serialization/deserialization and Gson uses reflection of internal `java.lang` classes -to do it. This is not allowed by default in Java 9 and above. +Snapshot releases overwrite each other, so no two releases are alike. If you find a bug in one of the `SNAPSHOT` versions that you'd like to report, please include the output of `Debug.printBuildInfo()` in the ticket's description. -To work around this, it's necessary to add this JVM commandline argument: +```java +import io.weaviate.client6.v1.internal.Debug; + +public class App { + public static void main(String[] args) { + Debug.printBuildInfo(); + + // ...the rest of your application code... + } +} +``` + +### Gson and reflective access to internal JDK classes + +The client uses Google's [`gson`](https://github.com/google/gson) for JSON de-/serialization which does reflection on internal `java.lang` classes. This is _not allowed by default_ in Java 9 and above. + +To work around this, it's necessary to add this JVM command line argument: ``` --add-opens=java.base/java.lang=ALL-UNNAMED @@ -46,49 +70,734 @@ applicationDefaultJvmArgs += listOf( ) ``` -Here's a simple code to start up working with Java client: +## Supported APIs + + +### Tucked Builder -1. Add dependency to your java project. +Tucked Builder is an iteration of the Builder pattern that reduces boilerplate and leverages static typing and autocompletion to help API discovery. +It is well-worth getting familiar with Tucked Builders before diving into the next sections, as the library makes intensive use of this pattern across its API surface. -2. Connect to Weaviate on `localhost:8080` and fetch meta information +If you've worked with Elasticserch Java API Client before, you'll recognize this pattern as [Builder lamba expressions](https://www.elastic.co/docs/reference/elasticsearch/clients/java/api-conventions/building-objects#_builder_lambda_expressions). + +Most operations in Weaviate have multiple optional parameters and Builder patter is a common way to implement that. For example, here's what a nearVector query _could_ look like: ```java -package io.weaviate; +import io.weaviate.client6.v1.api.collections.query.Hybrid; +import io.weaviate.client6.v1.api.collections.query.NearText; +import io.weaviate.client6.v1.api.collections.query.NearText.Move; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.Meta; +Move moveTo = Move.builder() + .force(.5f) + .concepts("lullaby") + .build(); +NearText nearText = NearText.builder() + .concepts("sunshine", "butterflies") + .distance(.4f) + .moveTo(moveTo) + .build(); +Hybrid hybridQuery = Hybrid.builder() + .concepts("rainbow") + .nearText(nearText) + .queryProperties("title", "lyrics") + .returnProperties("album", "author") + .build(); -public class App { - public static void main(String[] args) { - Config config = new Config("http", "localhost:8080"); - WeaviateClient client = new WeaviateClient(config); - Result meta = client.misc().metaGetter().run(); - if (meta.hasErrors()) { - System.out.printf("Error: %s\n", meta.getError().getMessages()); - } else { - System.out.printf("meta.hostname: %s\n", meta.getResult().getHostname()); - System.out.printf("meta.version: %s\n", meta.getResult().getVersion()); - System.out.printf("meta.modules: %s\n", meta.getResult().getModules()); - } +songs.query.hybrid(hybridQuery); +``` + +The Tucked Builder pattern replaces repetitive `.builder() [...] .build()` with a **lambda expression** which accepts the pre-instantiated builder object as its only argument. +If that's a mouthful, take a look at what the query above looks like in `client6`. After all, seeing is believing: + +```java +import io.weaviate.client6.v1.api.collections.query.NearText; + +songs.query.hybrid( + "rainbow", + /* Hybrid.Builder */ h -> h + .nearText(NearText.of( + List.of("sunshine", "butterflies"), + /* NearText.Builder */ nt -> nt + .distance(.4f) + .moveTo(.5f, /* NearText.Move.Builder */ to -> to.concepts("lullaby")) + ) + .queryProperties("title", "lyrics") + .returnProperties("album", "author") +); +``` + +Notice how the type of each lambda argument can be automatically deduced from the methods' signatures. This allows the autocomplete to correctly suggest possible arguments, guiding you through the query API. The builder itself is "tucked" in the method's internals, so you needn't remember how to access or import it. What's more, the code reads a lot more like a query thanks to improved [locality](https://htmx.org/essays/locality-of-behaviour/). As you'll see in the examples below, you can also get creative with naming the lambda argument to act as hint for future readers. + +In real-world programs there will be cases where you need to inject some control-flow statements in the query builder code. Consider an example of limiting the number of query results based on some external value, such as a URL query paramter. Lambda expressions are fully-fledged functions, so you could add a if-statement right in the middle of it: + +```java +songs.query.hybrid("rainbow", h -> { + if (limitURL != null) { + h.limit(limitURL); } + return h; +}); +``` + +This may get out of hand quickly if complex logic is involved. Or you may simply prefer the standard Builder pattern. Whichever's the case, `client6` has got you covered. Tucked builders are public members of the classes they build, so they can be used directly. + +```java +Hybrid.Builder builder = new Hybrid.Builder("rainbow"); +if (limitURL != null) { + builder.limit(limitURL) } + +// more complex steps... + +songs.query.hybrid(/* Hybrid */ builder.build()); ``` -## Documentation +Finally, if you need to separate "query definition" from "performing the query", most objects provide two static factories: one with only the required arguments and one with the required aruments and a tucked builder. -- [Documentation](https://weaviate.io/developers/weaviate/current/client-libraries/java.html). +```java +Hybrid requiredOnly = Hybrid.of("rainbow"); +Hybrid withOptional = Hybrid.of("rainbow", opt -> opt.limit(10)); +``` + +### Connecting to a Weaviate instance + +```java +WeaviateClient client = WeaviateClient.connectToCustom( + conn -> conn + .scheme("http") + .httpPort(8080).httpHost("localhost") + .grpcPort(50051).grpcHost("localhost") + .setHeader("X-Custom-Header", "Readme") +); +``` + +Shorthand methods for connecting to a local instance and a Weaviate Cloud cluster are available too: + +```java +// Defaults to scheme=http, host=localhost, port=8080, grpcHost=locahost, grpcPort=50051 +WeaviateClient local = WeaviateClient.connectToLocal(local -> local.port(9090)); + +// Always uses httpPort=443, grpcPort=443, httpHost == gprcHost == , and API Key authentication +WeaviateClient wcd = WeaviateClient.connectToWeaviateCloud("my-cluster-url.io", "my-api-key"); +``` + +> [!TIP] +> The client holds a number of resources (HTTP connection pools, gRPC channel) which must be disposed of correclty then they are no longer needed. +> If the client's lifecycle is tied to that of your app, closing the client via `client.close()` is a good way to do that. +> +> Otherwise, use the client inside a [try-with-resources](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html) statement: +> +>```java +> try (final var client = new WeaviateClient(config)) { +> // Do something with the client +> } +> ``` +> WeaviateClient will be automatically closed when execution exits the block. + + +#### Authentication + +Weaviate supports several authentication methods: + +| Method | Client API reference | +| ----------------------- | --------------------------------------------------------------- | +| API Key | `Authentication.apiKey("my-api-key")` | +| Resource owner password | `Authentication.resourceOwnerPassword("username", "password")` | +| Client credentials | `Authentication.clientCredentials("clientKey", "clientSecret")` | +| Existing bearer token | `Authentication.apiKey("access-token", "refresh-token", 900)` | + +Pass the preferred authentication method as an argument to the connection builder to use it in the client: + +```java +WeaviateClient.connectToCustom( + conn -> conn.authentication(Authentication.apiKey("my-api-key") +); +``` + +Follow the [documentation](https://docs.weaviate.io/deploy/configuration/authentication) for a detailed discussion. + + +### Collection management + +```java +client.collections.create( + "Songs", + collection -> collection + .properties( + Property.text("title"), + Property.text("lyrics", p -> p.tokenization(Tokenization.WORD)), + Property.integer("yearReleased"), + Property.blob("albumCover"), + Property.bool("isSingle") + ) + .references( + ReferenceProperty.to("hasAwards", "GrammyAwards", "BillboardMusicAwards") + ) + .vectorConfig( + VectorConfig.text2vecWeaviate("title_vec", t2v -> t2v.sourceProperties("title")), + VectorConfig.text2vecWeaviate("lyrics_vec", t2v -> t2v.sourceProperties("lyrics")), + VectorConfig.img2vecNeural("cover_vec", i2v -> i2v.imageFields("albumCover")) + ) +); + +assert client.collections.exists("Songs"); + +client.collections.delete("Songs"); +assert !client.collections.exists("Songs"); +``` + +Other methods in `collections` namespace include: + +- `getConfig(String collection)` to fetch collection configuration; +- `list()` to fetch collection configurations for all existing collections +- `deleteAll()` to drop all collections and their data + + +#### Using a Collection Handle + +Once a collection is created, you can obtain another client object that's scoped to that collection, called a _"handle"_. + +```java +CollectionHandle> songs = client.collections.use("Songs"); +``` + +Using the handle, we can ingest new data into the collection and query it, as well as modify the configuration. +The handle object is thread safe. Although lightweight, it is best created once and shared across threads / callers. + +```java +// Bad: creates a new CollectionHandle object for each iteration, strains the GC unnecessarily. +for (var song : mySongs) { + client.collections.use("Songs").data.insert(song); +} + +// Good: the same CollectionHandle is reused across multiple iterations / processes. +var songs = client.collections.use("Songs"); +Thread.run(() -> rapSongs.forEach(song -> songs.data.insert(song))); +Thread.run(() -> popSongs.forEach(song -> songs.data.insert(song))); +``` + +For the rest of the document, assume `songs` is handle for the "Songs" collection defined elsewhere. + + +#### Generic `PropertiesT` + +Weaviate client lets you insert object properties in different "shapes". The compile-time type in which the properties must be passed is determined by a generic paramter in CollectionHandle object. +By defalt, the value for this parameter is `Map`. That allows you to think of your data as JSON objects with some additional metadata (vector embedding, UUID, certainty score, etc.). + +In practice this means you'll be passing an instance of `Map` to insert a new object and receive its properties as `Map` when the collection is queried. + +If you prefer stricter typing, you can leverage our built-in ORM to work with properties as custom Java types. We will return to this in the **ORM** section later. Assume for now that properties are always being passed around as an "untyped" map. + + +### Ingesting data + +Data operations are concentrated behind the `.data` namespace. + + +#### Insert single object + +```java +var yellowSubmarine = songs.data.insert(Map.of( + "title", "Yellow Submarine", + "lyrics", "In the town where I was born...", + "year", 1969 +)); +System.out.println("Inserted new song at "+ yellowSubmarine.metadata().createdAt()); +System.out.println("Yellow Submarine uuid="+ yellowSubmarine.uuid()); +``` + +You can supply your own UUID and vector embedding: + +```java +songs.data.insert( + Map.of(...), + obj -> obj + .uuid("valid-custom-uuid") + .vectors(Vectors.of("title_vec", new float[]{...})) +); +``` + +#### `Vectors`? + +Weaviate supports 1-dimensional and multi-dimensional vector embeddings, thanks to ColBERT-family modules. The associated vector can be `float[] | float[][]`. +As Java does not have unions of primitive types, we define an abstraction called `Vectors` which is a container type for object's vector embeddings. + +Creating a new vector is simple: + +- `Vectors.of(new float[]{...})`: default 1-d vector +- `Vectors.of("custom_1d", new float[]{...})`: 1-d vector with a custom name +- `Vectors.of(new float[][]{...})`: default 2-d vector +- `Vectors.of("custom_2d", new float[][]{...})`: 2-d vector with a custom name +- `Vectors.of(Vectors.of(...), Vectors.of(...))`: Multiple vectors, all must define a custom name + +Here's how you can retrieve the actual vector associated with the object: + +```java +Vectors vectors = yellowSubmarine.vectors(); +float[] v = vectors.getDefaultSingle(); // default 1-dimensional vector +float[] v = vectors.getSingle("custom_1d"); // 1-d vector with a custom name +float[][] v = vectors.getDefaultMulti(); // default 2-dimensional vector +float[][] v = vectors.getMulti("custom_2d"); // 2-d vector with a custom name +``` + +#### Batch insert + +> [!NOTE] +> Support for Dynamic Batching in `client6` will be added once Server-Side Batching becomes GA in Weaviate (est. `v1.34`) + +```java +InsertManyResponse response = songs.data.insertMany( + Map.of("title", "High-Speed Dirt", "artist", "Megadeth"), + Map.of("title", "Rattlehead", "artist", "Megadeth") +); + +if (!response.errors().isEmpty()) { + throw new RuntimeException(String.join(", ", response.errors())); +} +System.out.println( + "Inserted %d objects, took: %.2fs" + .formatted(response.reponses().size(), response.took()) +); +``` + +To supply your own UUID and vector embedding when inserting multiple objects wrap each obejct in `WeaviateObject.of(...)`: + +```java +songs.data.insertMany( + WeaviateObject.of(map1, obj -> obj.uuid(uuid1)), + WeaviateObject.of(map2, obj -> obj.uuid(uuid2)) +) +``` + +### Querying data + +Query methods are concentrated behind the `.query` namespace. + +By default, _all object properties_ and its UUID are included in the response. To select a subset of properties, pass their names to `.returnProperties(...)` method on the tucked builder. Retrieve additional metadata (where relevant) like so: + +```java +// Distance and Certainty are only relevant to semantic search +q -> q.returnMetadata(Metadata.VECTOR, Metadata.DISTANCE, Metadata.CERTAINTY) + +// Score and Explain Score are only relevant to BM25 and hybrid queries +q -> q.returnMetadata(Metadata.SCORE, Metadata.EXPLAIN_SCORE) +``` + +#### Semantic search + +```java +songs.query.nearVector( + new float[]{...}, + nv -> nv.distance(.3f) +); + +songs.query.nearText( + "a song about weather", + nt -> nt.moveAway(.6f, from -> from.concepts("summertime")) +); + +songs.query.nearObject( + yellowSubmarine.uuid(), + nobj -> nobj.excludeSelf() +); + +songs.query.nearImage("base64-encoded-image"); +// Other "near-media" methods available: nearVideo, nearAudio, nearDepth, nearImu, nearThermal +``` + +> [!TIP] +> The first object returned in a NearObject query will _always_ be the search object itself. To filter it out, use the `.excludeSelf()` helper as in the example above. + + +#### Keyword and Hybrid search -## Support +```java +songs.query.bm25( + "rain", + bm25 -> bm25.queryProeperties("lyrics") +); + +songs.query.hybrid( + "rain", + h -> h + .queryProperties("lyrics") + .nearVector(NearVector.of(new float[]{...})) +); +``` + +#### Filtering + +Objects can be filtered by property or reference values. In the latter case you need to pass the "path" to the property in the referenced collection. + +```java +.filters(Filter.property("year").gte(1969)) +.filters(Filter.reference("hasAwards", "GrammyAwards", "category").eq("New Artist")) +``` + +Supported **comparison operators**: + +- Equal: `.eq` +- NotEqual: `.ne` +- LessThan: `.lt` +- LessThanEqual: `.lte` +- GreaterThan: `.gt` +- GreaterThanEqual: `.gte` +- Like: `.like` +- ContainsAll: `.containsAll` +- ContainsAny: `.containsAny` +- ContainsNone: `.containsNone` +- WithinGeoRange: `.withinGeoRange` + +Comparison operators can be grouped using **logical operators** with arbitrarily deep nesting. + +```java +.filters( + Filter.or( + Filter.and( + Filter.property("year").gt(2000), + Filter.property("year").lt(2017) + ), + Filter.or( + Filter.property("artist").like("Boys"), + Filter.property("genres").containsAny("#rock", "#rocknroll", "#grunge") + ) + ) +) +``` + +Supported **logical operators**: + +- And: `.and` +- Or: `.or` +- Not: `.not` + +Operators passed in subsequent calls to `.filters` are concatenated with the `.and` operartor. +These 3 calls are equivalent: + +```java +.filters(Filter.and(cond1, cond2)) +.filters(cond1, cond2) +.filters(cond1).filters(cond2) +``` + +To negate an operator, wrap it in `Filter.not(...)` or use the negation shorthand. + +```java +Filter.not(Filter.property("title").like("summer")); +Filter.property("title").like("summer").not(); +``` + +Passing `null` and empty `Filter[]` to any of the logical operators as well as to the `.filters()` method is safe -- the empty operators will simply be ignored. + + +#### Grouping results + +Every query above has an overloaded variant that accepts a group-by clause. + +```java +// Required arguments + GroupBy +songs.query.nearVector( + new float[]{...}, + GroupBy.property("artist", 10, 100) +); + +// Required argument, optional parameters, GroupBy +songs.query.bm25( + "rain", + bm25 -> bm25.queryProperties("lyrics"), + GroupBy.property("artist", 10, 100) +); +``` + +The shape of the response object is different too, see [`QueryResponseGrouped`](./src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGrouped.java). + + +### Pagination + +Paginating a Weaviate collection is straighforward and its API should is instantly familiar. `CursorSpliterator` powers 2 patterns for iterating over objects: + +- the default Paginator object returned by `collection.paginate()` implements Iterable that can be used in a traditional for-loop +- `.stream()` presents the internal Spliterator via an idiomatic Stream API + +```java +var allSongs = songs.paginate(); + +for (WeaviateObject song : allSongs) { + // Traditional for-loop +} + +// Stream API +var allSongUUIDs = allSongs.stream().map(WeaviateObject::uuid).toList(); +``` + +Paginator can be configured to return a subset of properties / metadata fields, use a different page size (defaults to 100) or resume iteration from an arbitrary object. + +```java +// Create a paginator +var allSongs = things.paginate( + p -> p + .pageSize(500) + .resumeFrom("uuid-3") + .returnProperties("artist", "album") + .returnMetadata(Metadata.VECTOR)); + +// Process data +allSongs.stream().toList(); +``` + +### Aggregating data + +```java +songs.aggregate.overAll( + with -> with + .metrics( + Aggregate.integer("year", calc -> calc.min().max().median()), + Aggregate.text("album", calc -> calc.topOccurrences().topOccurencesCutoff(5)), + Aggregate.bool("isSingle", calc -> calc.percentageTrue().totalFalse()), + Aggregate.number("monthlyListeners", calc -> calc.mode().count()) + ) + .includeTotalCount(true) +) +``` + +#### Filtered aggregations + +To perform aggregations over query results, use one of the other method under the `aggregate` namespace: it has the same set of methods as the `query` namespace, with the exception of `.bm25(...)`, which cannot be used as an aggregation filter. + +```java +songs.aggregate.hybrid( + "summer of love", + hybrid -> hybrid + .queryProperties("title", "lyrics") + .nearVector(NearVector.of( + new float[]{...}, + nv -> nv.certainty(.7f) + ) + .alpha(.3f), + aggregate -> aggregate + .metrics( + Aggregate.text("artist", calc -> calc.topOccurrences()) + ) +); +``` + +Similartly, an overload with another parameter for a group-by clause is available: + +```java +songs.aggregate.nearObject( + yellowSubmarine.uuid(), + nearObject -> nearObject.excludeSelf(), + aggregate -> aggregate.metrics( + Aggregate.text("album", calc -> calc.topOccurrences()) + ), + GroupBy.property("year") +); +``` + +#### Counting collection objects + +To query the total object count in a collection use `songs.size()` shorthand. + + +### Error handling + +The client throws exceptions extending `WeaviateException`, which can be used as a catch-all case for any package-related exceptions. Other exception types, such as `IOException` which may be thrown by the underlying HTTP / gRPC libraries are allowed to propagate, as they usually signal different kinds of errors: malformed URL, network problems, etc. + +> [!WARNING] +> `WeaviateException` is an **unchecked exception**. -- [Stackoverflow for questions](https://stackoverflow.com/questions/tagged/weaviate). -- [Github for issues](https://github.com/weaviate/java-client/issues). +```java +try (final var client = WeaviateClient.connectToLocal()) { + // Make some requests +} catch (WeaviateException | IOException e) { + e.printStackTrace(); +} +``` + +Concrete exception types: + +- `WeaviateApiException` - Bad request. +- `PaginationException` - Wrapper exception with pagination details (page size, last cursor UUID) +- `WeaviateConnectException` - Weaviate instance not available, failed to connect. +- `WeaviateOAuthException` - Error during OAuth credentials exchange. +- `WeaviateTransportException` - Internal transport layer exception. + + +### ORM + +Weaviate client comes with a minimal ORM, which lets you serialize and deserialize object properties into Java **records**. Moreover, the client can create a collection based on the record's declared fields. +The "Songs" collection that we've been working with so far may look somethins like this: + + +```java +import io.weaviate.client6.v1.api.collections.annotations.Collection; +import io.weaviate.client6.v1.api.collections.annotations.Property; + +@Collection("Songs", description = "Global media library") +record Song( + String title, + String lyrics, + @Property("artist") String singer, + int year, + String[] genres +) {} +``` + +By default, the class and field names map to the collection and property names respectively. The `@Collection` and `@Property` annotations can be used to override those defaults. + +To create the collection, pass the class definition to `.create`. + +```java +client.collections.create( + Song.class, + collection -> collection + .references(...) + .vectorConfig(...); +``` + +Ingestion and search work the same way, but will accept / return `Song.class` instances instead of `Map`. + +```java +Song bad = new Song("Bad", "...", "Michael Jackson", 1987, ...); +Song badGuy = new Song("Bad Guy", "...", "Billie Eilish", 2019, ...); +Song crown = new Song("You Should See Me in a Crown", "...", "Billie Eilish", 2019, ...); + +songs.data.insert(bad); +songs.data.insertMany(badGuy, crown); + +var result = songs.query.bm25( + "bad", + opt -> opt + .queryProperties("lyrics") + .returnProperties("artist") +); + +for (var object : result.objects()) { + Song song = object.properties(); + System.out.println(song.artist()); +} +``` + +When _ingetsting_ data, Java records can be used to represent nested object properties: + +```java +record MusicVideo(@Property("link") String url, long runtimeSeconds) {} + +songs.data.insert(Map.of( + "title", "Billie Jean", + "musicVideo", new MusicVideo("https://youtube.com/billijean", 294L), +)); +``` + +We want to stress that this ORM's focus is on improving type-safety around object properties and simplifying serialization/deserialization. It is intentionally kept minimal and as such has the following limitations: + +- **Does not support BLOB properties.** On the wire, blob properties are represented as base64-encoded strings, and both logically map to the Java's `String`. Presently there isn't a good way for the client to deduce which property type should be created, so it always maps `Sting -> TEXT`. +- **Limited configuration options.** Vector indices, replication, multi-tenancy, and such need to be configured via a tucked builder in `.create(..., here -> here)`. +- **Cannot include nested objects.** Java records can be used as nested properties in a `Map`, but cannot include nested properties themselves. +- **Does not support cross-references.** Properties and Cross-References are conceptually and "physically" separated in Weaviate' client libraries, so doing something like in the snippet below is not supported. + +```java +record Artist(String firstName, String lastName, int age) {}; + +record Song(String title, Artist artist) {}; + +var song1 = songs.query.fetchObjectById( + uuid1, + song -> song.returnReferences(QueryReference.single("artist")) +); +System.out.println( + "Artist's last name is: " + + song1.properties().artist().lastName() +); +``` + +Instead you'd work with cross-references same way as without the ORM: + +```java +System.out.println( + "Artist's last name is: " + + song1.references().get("artist").properties().get("lastName") +); +``` + +Some of these features may be added in future releases. + + +### Collection alias + +```java +client.collections.alias("RapSongs", "Songs_Alias"); +client.collections.list(only -> only.collection("RapSongs")); +client.collections.get("Songs_Alias"); +client.collections.update("Songs_Alias", "PopSongs"); +client.collections.delete("Songs_Alias"); +``` + +### Managing collection backups + +> [!CAUTION] +> Weaviate does not support concurrent backups. Await one backup's completion before starting another one. + +```java +// Start a backup: +Backup backup = client.backup.create( + "backup_1", "filesystem", + bak -> bak + .includeCollections("Songs", "Artists") + .compressionLevel(CompressionLevel.BEST_COMPRESSION) + .cpuPercentage(30) +); + +// By default, the client does not monitor the backup status. +// The above method returns as soon as the server acknowledges +// the request and starts to process it. +// +// Now you can poll backup status to know when it is succeedes (or fails). + +Backup status = client.backup.getCreateStatus(backup.id(), backup.backend()); +if (status.status() == BackupStatus.SUCCESSFUL) { + System.out.println("Yay!"); + System.exit(0); +} + +// Backups may take a write to complete. To block the current thread until +// the execution completes, call Backup::waitForCompletion(WeaviateClient). +// +// Notice that, while we use `backup` object we can also call it on the `status`, +// as both will have sufficient information to identify the backup operation. + +try { + Backup completed = backup.waitForCompletion(client); + assert completed.errors() == null : "completed with errors"; +} catch (TimeoutException e) { + System.out.exit(1); +} + +// List exists backups: +List allBackups = client.backup.list(); + +// Restore from the first backup: +var first = allBackups.getFirst(); +client.backup.restore(first.id(), first.backend()); + +// Similarly, wait until the restore is complete using Backup::waitForCompletion. +// It is possible to set a custom timeout and polling interval using a familiar Tucked Builder pattern: + +var restoring = client.backup.getRestoreStatus(first.id(), first.backend()); +var restored = restoring.waitForCompletion(client, wait -> wait + .timeout(Duration.ofMinutes(30)) + .interval(Duration.ofMinutes(5))); + +assert restored.errors() == null : "restored with errors"; +``` + +## Useful resources + +- [Documentation](https://weaviate.io/developers/weaviate/current/client-libraries/java.html). +- [StackOverflow for questions about Weaviate](https://stackoverflow.com/questions/tagged/weaviate). +- [Github for issues in client6](https://github.com/weaviate/java-client/issues). ## Contributing - [How to Contribute](https://github.com/weaviate/java-client/blob/main/CONTRIBUTE.md). -## Build Status - -[![Build Status](https://github.com/weaviate/java-client/actions/workflows/.github/workflows/test.yaml/badge.svg?branch=main)](https://github.com/weaviate/java-client/actions/workflows/.github/workflows/test.yaml) diff --git a/logo.png b/logo.png new file mode 100644 index 000000000..f6974dfd3 Binary files /dev/null and b/logo.png differ diff --git a/pom.xml b/pom.xml index c6f1210a9..7a98a1a84 100644 --- a/pom.xml +++ b/pom.xml @@ -3,17 +3,13 @@ 4.0.0 io.weaviate - client - 5.6.1-SNAPSHOT - pom + client6 + jar + 6.0.2-SNAPSHOT - Weaviate Java Client - - This artifact has been relocated to io.weaviate.client6. - The new version includes a number of breaking changes. - Please consult our migration guide: https://weaviate.io/blog/weaviate-java-client-v6#migration-guide. - - https://github.com/weaviate/java-client/tree/v5 + ${project.groupId}:${project.artifactId} + Official Java client for Weaviate Vector Search Engine + https://github.com/weaviate/java-client Weaviate B.V. @@ -34,25 +30,376 @@ Weaviate B.V. https://www.weaviate.io + + Dyma Solovei + dyma@weaviate.io + Weaviate B.V. + https://www.weaviate.io + scm:git:git://github.com/weaviate/java-client.git scm:git:ssh://github.com:weaviate/java-client.git - https://github.com/weaviate/java-client/tree/v5 - 5.6.0 + https://github.com/weaviate/java-client/tree/main + 6.0.1 - - - io.weaviate - client6 - - + + UTF-8 + UTF-8 + UTF-8 + 17 + 17 + 17 + 1.18.42 + 2.13.2 + 5.6 + 3.20.0 + 4.13.2 + 2.0.3 + 3.27.6 + 1.0.4 + 5.21.0 + 2.0.17 + 1.5.18 + 5.14.0 + 2.21 + 11.31.1 + 5.15.0 + 4.33.4 + 4.33.4 + 1.78.0 + 1.78.0 + 1.78.0 + 6.0.53 + + + + + com.google.protobuf + protobuf-java + ${protobuf.java.version} + + + com.google.protobuf + protobuf-java-util + ${protobuf.java-util.version} + + + io.grpc + grpc-netty-shaded + ${grpc-netty-shaded.version} + + + io.grpc + grpc-protobuf + ${grpc-protobuf.version} + + + io.grpc + grpc-stub + ${grpc-stub.version} + + + org.apache.tomcat + annotations-api + ${annotations-api.version} + provided + + + org.apache.httpcomponents.client5 + httpclient5 + ${httpclient.version} + + + org.projectlombok + lombok + ${lombok.version} + + + com.google.code.gson + gson + ${gson.version} + + + org.apache.commons + commons-lang3 + ${lang3.version} + + + com.nimbusds + oauth2-oidc-sdk + ${oauth2-oidc-sdk.version} + + + org.testcontainers + testcontainers-weaviate + ${testcontainers.version} + test + + + org.testcontainers + testcontainers-minio + ${testcontainers.version} + test + + + org.assertj + assertj-core + ${assertj-core.version} + test + + + junit + junit + ${junit.version} + test + + + com.jparams + jparams-junit4 + ${jparams.version} + test + + + org.mockito + mockito-core + ${mockito.version} + test + + + org.slf4j + slf4j-nop + ${slf4j.version} + test + + + org.mock-server + mockserver-netty-no-dependencies + ${mock-server.version} + test + + + com.fasterxml.jackson.core + jackson-annotations + ${jackson.version} + test + + + + + kr.motd.maven + os-maven-plugin + 1.7.1 + + + + org.xolstice.maven.plugins + protobuf-maven-plugin + 0.6.1 + + com.google.protobuf:protoc:3.24.0:exe:${os.detected.classifier} + src/main/java + grpc-java + io.grpc:protoc-gen-grpc-java:1.58.0:exe:${os.detected.classifier} + src/main/java + false + + + + + compile + compile-custom + test-compile + test-compile-custom + + + + + + maven-clean-plugin + 3.1.0 + + + maven-resources-plugin + 3.2.0 + + + maven-compiler-plugin + 3.13.0 + + + maven-surefire-plugin + 3.5.4 + + false + classes + 4 + true + 1 + true + balanced + + + + org.projectlombok + lombok-maven-plugin + 1.18.20.0 + + + delombok-sources + generate-sources + + delombok + + + src/main/java + ${project.build.directory}/delombok + false + UTF-8 + + + + + + org.projectlombok + lombok + ${lombok.version} + + + + + org.apache.maven.plugins + maven-antrun-plugin + 3.0.0 + + + generate-delomboked-sources-jar + package + + run + + + + + + + + + + + org.codehaus.mojo + versions-maven-plugin + 2.18.0 + + false + false + + + + regex + (.+-SNAPSHOT|.+-(M|RC|rc)\d|.+-(alpha|beta)\d?) + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.2.0 + + + attach-delomboked-sources-jar + package + + attach-artifact + + + + + ${project.build.directory}/${project.build.finalName}-sources.jar + jar + sources + + + + + + add-test-source + generate-test-sources + + add-test-source + + + + ${project.basedir}/src/it/java + ${project.basedir}/src/it/resources + + + + + + + pl.project13.maven + git-commit-id-plugin + 4.9.10 + + + get-the-git-infos + + revision + + initialize + + + + true + true + ${project.build.outputDirectory}/client6-git.properties + full + false + false + + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.11.2 + + + attach-javadocs + package + + jar + + + + + ${project.build.directory}/delombok + + all,-missing + + + + org.apache.maven.plugins + maven-source-plugin + 3.2.1 + + + attach-sources + package + + jar-no-fork + + + + org.apache.maven.plugins maven-gpg-plugin @@ -77,6 +424,15 @@ + + maven-jar-plugin + 3.2.0 + + + maven-install-plugin + 3.0.0-M1 + + @@ -102,9 +458,85 @@ ${central-publishing.waitUntil} + + + maven-site-plugin + 3.9.1 + + + maven-project-info-reports-plugin + 3.1.1my + + + + org.apache.maven.plugins + maven-shade-plugin + 3.6.0 + + false + true + all + + + + + + + + + com.google.protobuf + io.weaviate.shaded.com.google.protobuf + + + io.grpc + io.weaviate.shaded.io.grpc + + + org.slf4j + io.weaviate.shaded.org.slf4j + + + + + + package + + shade + + + + + + org.projectlombok + lombok-maven-plugin + + + org.xolstice.maven.plugins + protobuf-maven-plugin + + + org.apache.maven.plugins + maven-antrun-plugin + + + org.codehaus.mojo + build-helper-maven-plugin + + + org.apache.maven.plugins + maven-shade-plugin + + + org.apache.maven.plugins + maven-javadoc-plugin + + + pl.project13.maven + git-commit-id-plugin + org.apache.maven.plugins maven-gpg-plugin diff --git a/src/it/java/io/weaviate/ConcurrentTest.java b/src/it/java/io/weaviate/ConcurrentTest.java new file mode 100644 index 000000000..6e783ff06 --- /dev/null +++ b/src/it/java/io/weaviate/ConcurrentTest.java @@ -0,0 +1,135 @@ +package io.weaviate; + +import java.util.Random; +import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.apache.commons.lang3.RandomStringUtils; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.Assumptions; +import org.junit.Rule; +import org.junit.rules.TestName; + +import io.weaviate.client6.v1.internal.VersionSupport.SemanticVersion; +import io.weaviate.containers.Weaviate; + +/** + * ConcurrentTest is the base class for integration tests, which provides + * utility methods to uniqualize collections and objects created in the + * database. + * + * Because we want to re-use the same database container across most of the + * test suites and (eventually) run them in parallel, + * test classes should extend this class and use its methods + * to avoid name clashes in the shared Weaviate instance. + */ +public abstract class ConcurrentTest { + @Rule + public TestName currentTest = new TestName(); + + protected static final Random rand = new Random(); + + /** + * Add unique namespace prefix to the string. + * + * @param value Collection name, object ID, etc., which has to be unique across + * all test suites. + * @return Value prefixed with the name of the current test suite + test method. + */ + protected String ns(String value) { + String cls = getClass().getSimpleName(); + String method = currentTest.getMethodName(); + return cls + "_" + method + "_" + value; + } + + /** Appends random characters to create unique value. */ + protected static String unique(String value) { + var randString = RandomStringUtils.insecure().next(8, true, false); + return value + "_" + randString; + } + + /** Generate random UUID. */ + protected static String randomUUID() { + return UUID.randomUUID().toString(); + } + + /** + * Generate a random vector. + * + * @param length Vector length. + * @param origin Value range lower bound. + * @param bound Value range upper bound. + * @return + */ + protected static float[] randomVector(int length, float origin, float bound) { + var vector = new float[length]; + for (var i = 0; i < length; i++) { + vector[i] = rand.nextFloat(origin, bound); + } + return vector; + } + + /** + * Check that a condition is eventually met. + * + * @param cond Arbitrary code that evaluates the test condition.. + * @param intervalMillis Polling interval. + * @param timeoutSeconds Maximum waiting time. + * @param message Optional failure message. + * + * @throws AssertionError if the condition does not evaluate to true + * within {@code timeoutSeconds} or a thread + * was interrupted in the meantime. + * @throws RuntimeException if an exception occurred when envalating condition. + */ + public static void eventually(Callable cond, int intervalMillis, int timeoutSeconds, String... message) { + var check = CompletableFuture.runAsync(() -> { + try { + while (!Thread.currentThread().isInterrupted() && !cond.call()) { + try { + Thread.sleep(intervalMillis); + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + } + } + } catch (Exception e) { + // Propagate to callee + throw new RuntimeException(e); + } + }); + + try { + check.get(timeoutSeconds, TimeUnit.SECONDS); + } catch (TimeoutException ex) { + check.cancel(true); + Assertions.fail(message.length >= 0 ? message[0] : null, ex); + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + Assertions.fail(ex); + } catch (ExecutionException ex) { + throw new RuntimeException(ex); + } + } + + /** + * Skip the test if the version that the {@link Weaviate} + * container is running is older than the required one. + */ + public static void requireAtLeast(Weaviate.Version required) { + var actual = SemanticVersion.of(Weaviate.VERSION); + Assumptions.assumeThat(actual) + .as("requires at least %s, but running %s", required.semver, actual) + .isGreaterThanOrEqualTo(required.semver); + } + + public static void requireAtLeast(Weaviate.Version required, Runnable r) { + var actual = SemanticVersion.of(Weaviate.VERSION); + if (actual.compareTo(required.semver) >= 0) { + r.run(); + } + } +} diff --git a/src/it/java/io/weaviate/containers/Container.java b/src/it/java/io/weaviate/containers/Container.java new file mode 100644 index 000000000..304dbea91 --- /dev/null +++ b/src/it/java/io/weaviate/containers/Container.java @@ -0,0 +1,88 @@ +package io.weaviate.containers; + +import java.util.Arrays; +import java.util.List; + +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runners.model.Statement; +import org.testcontainers.containers.GenericContainer; +import org.testcontainers.containers.Network; +import org.testcontainers.lifecycle.Startable; + +import io.weaviate.client6.v1.api.WeaviateClient; + +public class Container { + public static final Weaviate WEAVIATE = Weaviate.createDefault(); + public static final Model2Vec MODEL2VEC = Model2Vec.createDefault(); + public static final Img2VecNeural IMG2VEC_NEURAL = Img2VecNeural.createDefault(); + public static final MinIo MINIO = MinIo.createDefault(); + + public static ContainerGroup compose(Weaviate weaviate, GenericContainer... containers) { + return new ContainerGroup(weaviate, containers); + } + + public static TestRule asTestRule(Startable container) { + return new PerTestSuite(container); + }; + + public static class ContainerGroup implements Startable { + private final Weaviate weaviate; + private final List> containers; + + private ContainerGroup(Weaviate weaviate, GenericContainer... containers) { + this.weaviate = weaviate; + this.containers = Arrays.asList(containers); + + weaviate.dependsOn(containers); + setSharedNetwork(); + } + + public WeaviateClient getClient() { + return weaviate.getClient(); + } + + @Override + public void start() { + weaviate.start(); // testcontainers will resolve dependencies + } + + @Override + public void stop() { + weaviate.stop(); + containers.forEach(GenericContainer::stop); + } + + private void setSharedNetwork() { + weaviate.setNetwork(Network.SHARED); + containers.forEach(c -> c.setNetwork(Network.SHARED)); + } + + public TestRule asTestRule() { + return new PerTestSuite(this); + }; + } + + public static class PerTestSuite implements TestRule { + private final Startable container; + + public PerTestSuite(Startable container) { + this.container = container; + } + + @Override + public Statement apply(Statement base, Description description) { + return new Statement() { + @Override + public void evaluate() throws Throwable { + try { + container.start(); + base.evaluate(); + } finally { + container.stop(); + } + } + }; + } + } +} diff --git a/src/it/java/io/weaviate/containers/Img2VecNeural.java b/src/it/java/io/weaviate/containers/Img2VecNeural.java new file mode 100644 index 000000000..28bddd990 --- /dev/null +++ b/src/it/java/io/weaviate/containers/Img2VecNeural.java @@ -0,0 +1,38 @@ +package io.weaviate.containers; + +import org.testcontainers.containers.GenericContainer; + +public class Img2VecNeural extends GenericContainer { + public static final String DOCKER_IMAGE = "cr.weaviate.io/semitechnologies/img2vec-pytorch"; + public static final String VERSION = "resnet50"; + + public static final String MODULE = "img2vec-neural"; + public static final String HOST_NAME = MODULE; + public static final String URL = HOST_NAME + ":8080"; + + static Img2VecNeural createDefault() { + return new Builder().build(); + } + + static Img2VecNeural.Builder custom() { + return new Builder(); + } + + public static class Builder { + private String versionTag; + + public Builder() { + this.versionTag = VERSION; + } + + public Img2VecNeural build() { + var container = new Img2VecNeural(DOCKER_IMAGE + ":" + versionTag); + container.withCreateContainerCmdModifier(cmd -> cmd.withHostName(HOST_NAME)); + return container; + } + } + + public Img2VecNeural(String image) { + super(image); + } +} diff --git a/src/it/java/io/weaviate/containers/MinIo.java b/src/it/java/io/weaviate/containers/MinIo.java new file mode 100644 index 000000000..86d0d649a --- /dev/null +++ b/src/it/java/io/weaviate/containers/MinIo.java @@ -0,0 +1,23 @@ +package io.weaviate.containers; + +import org.testcontainers.containers.MinIOContainer; + +public class MinIo extends MinIOContainer { + private static final String DOCKER_IMAGE = "minio/minio"; + public static final String ACCESS_KEY = "minioadmin"; + public static final String SECRET_KEY = "minioadmin"; + + public static final String HOST_NAME = "minio"; + public static final String URL = HOST_NAME + ":9000"; + + static MinIo createDefault() { + return new MinIo(); + } + + private MinIo() { + super(DOCKER_IMAGE); + withUserName(ACCESS_KEY); + withPassword(SECRET_KEY); + withCreateContainerCmdModifier(cmd -> cmd.withHostName("minio")); + } +} diff --git a/src/it/java/io/weaviate/containers/Model2Vec.java b/src/it/java/io/weaviate/containers/Model2Vec.java new file mode 100644 index 000000000..980a65a81 --- /dev/null +++ b/src/it/java/io/weaviate/containers/Model2Vec.java @@ -0,0 +1,40 @@ +package io.weaviate.containers; + +import org.testcontainers.containers.GenericContainer; + +import io.weaviate.client6.v1.api.collections.VectorConfig; + +public class Model2Vec extends GenericContainer { + public static final String VERSION = "minishlab-potion-base-4M"; + public static final String DOCKER_IMAGE = "cr.weaviate.io/semitechnologies/model2vec-inference"; + public static final String MODULE = VectorConfig.Kind.TEXT2VEC_MODEL2VEC.jsonValue(); + + public static final String HOST_NAME = "model2vec"; + public static final String URL = HOST_NAME + ":8080"; + + static Model2Vec createDefault() { + return new Builder().build(); + } + + static Model2Vec.Builder custom() { + return new Builder(); + } + + public static class Builder { + private String versionTag; + + public Builder() { + this.versionTag = VERSION; + } + + public Model2Vec build() { + var container = new Model2Vec(DOCKER_IMAGE + ":" + versionTag); + container.withCreateContainerCmdModifier(cmd -> cmd.withHostName(HOST_NAME)); + return container; + } + } + + public Model2Vec(String image) { + super(image); + } +} diff --git a/src/it/java/io/weaviate/containers/Weaviate.java b/src/it/java/io/weaviate/containers/Weaviate.java new file mode 100644 index 000000000..0f463e96f --- /dev/null +++ b/src/it/java/io/weaviate/containers/Weaviate.java @@ -0,0 +1,446 @@ +package io.weaviate.containers; + +import java.io.IOException; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; + +import org.testcontainers.containers.Network; +import org.testcontainers.containers.wait.strategy.Wait; +import org.testcontainers.lifecycle.Startable; +import org.testcontainers.weaviate.WeaviateContainer; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.Config; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.VersionSupport.SemanticVersion; + +public class Weaviate extends WeaviateContainer { + public static final String DOCKER_IMAGE = "semitechnologies/weaviate"; + public static final String LATEST_VERSION = Version.V135.semver.toString(); + public static final String VERSION; + + static { + VERSION = System.getenv().getOrDefault("WEAVIATE_VERSION", LATEST_VERSION); + } + public static String OIDC_ISSUER = "https://auth.wcs.api.weaviate.io/auth/realms/SeMI"; + + private volatile SharedClient clientInstance; + private final String containerName; + + public enum Version { + V132(1, 32, 24), + V133(1, 33, 11), + V134(1, 34, 7), + V135(1, 35, 2); + + public final SemanticVersion semver; + + private Version(int major, int minor, int patch) { + this.semver = new SemanticVersion(major, minor, patch); + } + + public void orSkip() { + ConcurrentTest.requireAtLeast(this); + } + } + + /** + * By default, testcontainer's name is only available after calling + * {@link #start}. + * We need to know each container's name in advance to run a cluster + * of several nodes, in which case we alse set the name manually. + * + * @see Builder#build() + */ + @Override + public String getContainerName() { + return containerName != null + ? containerName + : super.getContainerName(); + } + + /** + * Create a new instance of WeaviateClient connected to this container if none + * exist. Get an existing client otherwise. + * + * The lifetime of this client is tied to that of its container, which means + * that you do not need to {@code close} it manually. It will only truly close + * after the parent Testcontainer is stopped. + */ + public WeaviateClient getClient() { + if (!isRunning()) { + start(); + } + if (clientInstance != null) { + return clientInstance; + } + + synchronized (this) { + if (clientInstance == null) { + try { + clientInstance = new SharedClient(Config.of(defaultConfigFn()), this); + } catch (Exception e) { + throw new RuntimeException("create WeaviateClient for Weaviate container", e); + } + } + } + return clientInstance; + } + + /** + * Get client that is not shared with other tests / callers. + * The returned client is not wrapped in an instance of {@link SharedClient}, + * so it can be auto-closed by the try-with-resources statement when it exists. + */ + public WeaviateClient getBareClient() { + if (!isRunning()) { + start(); + } + try { + return new WeaviateClient(Config.of(defaultConfigFn())); + } catch (Exception e) { + throw new RuntimeException("create WeaviateClient for Weaviate container", e); + } + } + + /** + * Create a new instance of WeaviateClient connected to this container. + * Prefer using {@link #getClient} unless your test needs the initialization + * steps to run, e.g. OIDC authorization grant exchange. + */ + public WeaviateClient getClient(Function> fn) { + if (!isRunning()) { + start(); + } + + var customFn = ObjectBuilder.partial(fn, defaultConfigFn()); + var config = customFn.apply(new Config.Custom()).build(); + try { + return new WeaviateClient(config); + } catch (Exception e) { + throw new RuntimeException("create WeaviateClient for Weaviate container", e); + } + } + + private Function> defaultConfigFn() { + var host = getHost(); + return conn -> conn + .scheme("http") + .httpHost(host).httpPort(getMappedPort(8080)) + .grpcHost(host).grpcPort(getMappedPort(50051)); + } + + public static Weaviate createDefault() { + return new Builder().build(); + } + + public static Weaviate.Builder custom() { + return new Builder(); + } + + public static class Builder { + private String versionTag = VERSION; + private String containerName = "weaviate"; + private Set enableModules = new HashSet<>(); + private Set adminUsers = new HashSet<>(); + private Set viewerUsers = new HashSet<>(); + private Map environment = new HashMap<>(); + + public Builder() { + addModules(Reranker.Kind.DUMMY.jsonValue(), Generative.Kind.DUMMY.jsonValue()); + enableAutoSchema(false); + } + + public Builder withContainerName(String containerName) { + this.containerName = containerName; + return this; + } + + public Builder withVersion(String version) { + this.versionTag = version; + return this; + } + + public Builder addModules(String... modules) { + enableModules.addAll(Arrays.asList(modules)); + return this; + } + + public Builder withDefaultVectorizer(String module) { + addModules(module); + environment.put("DEFAULT_VECTORIZER_MODULE", module); + return this; + } + + public Builder withModel2VecUrl(String url) { + addModules(Model2Vec.MODULE); + environment.put("MODEL2VEC_INFERENCE_API", "http://" + url); + return this; + } + + public Builder withImageInference(String url, String module) { + addModules(module); + environment.put("IMAGE_INFERENCE_API", "http://" + url); + return this; + } + + public Builder withOffloadS3(String accessKey, String secretKey) { + addModules("offload-s3"); + environment.put("OFFLOAD_S3_ENDPOINT", "http://" + MinIo.URL); + environment.put("OFFLOAD_S3_BUCKET_AUTO_CREATE", "true"); + environment.put("AWS_ACCESS_KEY_ID", accessKey); + environment.put("AWS_SECRET_KEY", secretKey); + return this; + } + + public Builder withFilesystemBackup(String fsPath) { + addModules("backup-filesystem"); + environment.put("BACKUP_FILESYSTEM_PATH", fsPath); + return this; + } + + public Builder withAdminUsers(String... admins) { + adminUsers.addAll(Arrays.asList(admins)); + return this; + } + + public Builder withViewerUsers(String... viewers) { + viewerUsers.addAll(Arrays.asList(viewers)); + return this; + } + + /** Enable RBAC authorization for this container. */ + public Builder withRbac() { + environment.put("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); + environment.put("AUTHENTICATION_APIKEY_ENABLED", "true"); + environment.put("AUTHORIZATION_RBAC_ENABLED", "true"); + environment.put("AUTHENTICATION_DB_USERS_ENABLED", "true"); + return this; + } + + /** + * Enable API-Key authentication for this container. + * + * @param apiKeys Allowed API keys. + */ + public Builder withApiKeys(String... apiKeys) { + environment.put("AUTHENTICATION_APIKEY_ENABLED", "true"); + environment.put("AUTHENTICATION_APIKEY_ALLOWED_KEYS", String.join(",", + apiKeys)); + return this; + } + + public Builder withGrpcMaxMessageSize(int bytes) { + environment.put("GRPC_MAX_MESSAGE_SIZE", String.valueOf(bytes)); + return this; + } + + public Builder enableTelemetry(boolean enable) { + environment.put("DISABLE_TELEMETRY", Boolean.toString(!enable)); + return this; + } + + public Builder enableAutoSchema(boolean enable) { + environment.put("AUTOSCHEMA_ENABLED", Boolean.toString(!enable)); + return this; + } + + public Builder enableAnonymousAccess(boolean enable) { + environment.put("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", Boolean.toString(enable)); + return this; + } + + /** User default OIDC provider for integration tests. */ + public Builder withOIDC() { + return withOIDC( + "Peuc12y02UA0eAED1dqSjE5HtGUrpBsx", + "https://auth.weaviate.cloud/Peuc12y02UA0eAED1dqSjE5HtGUrpBsx", + "email", "roles"); + + } + + public Builder withOIDC(String clientId, String issuer, String usernameClaim, String groupsClaim) { + enableAnonymousAccess(false); + environment.put("AUTHENTICATION_OIDC_ENABLED", "true"); + environment.put("AUTHENTICATION_OIDC_CLIENT_ID", clientId); + environment.put("AUTHENTICATION_OIDC_ISSUER", issuer); + environment.put("AUTHENTICATION_OIDC_USERNAME_CLAIM", usernameClaim); + environment.put("AUTHENTICATION_OIDC_GROUPS_CLAIM", groupsClaim); + return this; + } + + public Weaviate build() { + var c = new Weaviate(containerName, DOCKER_IMAGE + ":" + versionTag); + + if (!enableModules.isEmpty()) { + c.withEnv("ENABLE_API_BASED_MODULES", Boolean.TRUE.toString()); + c.withEnv("ENABLE_MODULES", String.join(",", enableModules)); + } + + var apiKeyUsers = new HashSet(); + apiKeyUsers.addAll(adminUsers); + apiKeyUsers.addAll(viewerUsers); + + if (!adminUsers.isEmpty()) { + environment.put("AUTHORIZATION_ADMIN_USERS", String.join(",", adminUsers)); + } + if (!viewerUsers.isEmpty()) { + environment.put("AUTHORIZATION_VIEWER_USERS", String.join(",", viewerUsers)); + } + if (!apiKeyUsers.isEmpty()) { + environment.put("AUTHENTICATION_APIKEY_USERS", String.join(",", apiKeyUsers)); + } + + environment.forEach((name, value) -> c.withEnv(name, value)); + c.withCreateContainerCmdModifier(cmd -> cmd.withHostName(containerName)); + return c; + } + } + + private Weaviate() { + this("weaviate", DOCKER_IMAGE + ":" + VERSION); + } + + private Weaviate(String containerName, String dockerImageName) { + super(dockerImageName); + this.containerName = containerName; + } + + @Override + public void stop() { + // Note: at the moment containers which are not created as a @TestRule + // will not be "stopped", so client's resources are also not being freed. + // This is fine in tests, but may produce warnings about the gRPC channel + // not shut down properly. + super.stop(); + if (clientInstance == null) { + return; + } + synchronized (this) { + try { + clientInstance.close(this); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + } + + /** SharedClient's lifetime is tied to that of it's parent container. */ + private class SharedClient extends WeaviateClient { + private final Weaviate parent; + + private SharedClient(Config config, Weaviate parent) { + super(config); + this.parent = parent; + } + + private void close(Weaviate caller) throws Exception { + if (caller == parent) { + super.close(); + } + } + + @Override + public void close() throws IOException { + } + } + + public static Weaviate cluster(int replicas) { + List nodes = new ArrayList<>(); + for (var i = 0; i < replicas; i++) { + nodes.add(Weaviate.custom() + .withContainerName("weaviate-" + i) + .build()); + } + return new Cluster(nodes); + } + + public static class Cluster extends Weaviate { + /** Leader and followers combined. */ + private final List nodes; + + private final Weaviate leader; + private final List followers; + + private Cluster(List nodes) { + assert nodes.size() > 1 : "cluster must have 1+ nodes"; + + this.nodes = List.copyOf(nodes); + this.leader = nodes.remove(0); + this.followers = List.copyOf(nodes); + + for (var follower : followers) { + follower.dependsOn(leader); + } + setNetwork(Network.SHARED); + bindNodes(7110, 7111, 8300); + } + + @Override + public WeaviateContainer dependsOn(List startables) { + leader.dependsOn(startables); + return this; + } + + @Override + public void setNetwork(Network network) { + nodes.forEach(node -> node.setNetwork(network)); + } + + @Override + public WeaviateClient getClient() { + if (!isRunning()) { + start(); + } + return leader.getClient(); + } + + @Override + public void start() { + followers.forEach(Startable::start); // testcontainers will resolve dependencies + } + + @Override + public void stop() { + followers.forEach(Startable::stop); + leader.stop(); + } + + /** + * Set environment variables for inter-cluster communication. + * + * @param gossip Gossip bind port. + * @param data Data bind port. + * @param raft RAFT port. + */ + private void bindNodes(int gossip, int data, int raft) { + var publicPort = leader.getExposedPorts().get(0); // see WeaviateContainer Testcontainer. + + nodes.forEach(node -> node + .withEnv("CLUSTER_GOSSIP_BIND_PORT", String.valueOf(gossip)) + .withEnv("CLUSTER_DATA_BIND_PORT", String.valueOf(data)) + .withEnv("REPLICA_MOVEMENT_ENABLED", "true") + .withEnv("RAFT_PORT", String.valueOf(raft)) + .withEnv("RAFT_BOOTSTRAP_EXPECT", "1")); + + followers.forEach(node -> node + .withEnv("CLUSTER_JOIN", leader.containerName + ":" + gossip) + .withEnv("RAFT_JOIN", leader.containerName) + .waitingFor( + Wait.forHttp("/v1/.well-known/ready") + .forPort(publicPort) + .forStatusCode(200) + .withStartupTimeout(Duration.ofSeconds(10)))); + } + } +} diff --git a/src/it/java/io/weaviate/integration/AggregationITest.java b/src/it/java/io/weaviate/integration/AggregationITest.java new file mode 100644 index 000000000..30df82fb5 --- /dev/null +++ b/src/it/java/io/weaviate/integration/AggregationITest.java @@ -0,0 +1,177 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.function.Supplier; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.BeforeClass; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.aggregate.Aggregate; +import io.weaviate.client6.v1.api.collections.aggregate.AggregateResponseGroup; +import io.weaviate.client6.v1.api.collections.aggregate.AggregateResponseGrouped; +import io.weaviate.client6.v1.api.collections.aggregate.GroupBy; +import io.weaviate.client6.v1.api.collections.aggregate.GroupedBy; +import io.weaviate.client6.v1.api.collections.aggregate.IntegerAggregation; +import io.weaviate.containers.Container; + +public class AggregationITest extends ConcurrentTest { + private static WeaviateClient client = Container.WEAVIATE.getClient(); + private static final String COLLECTION = unique("Things"); + + @BeforeClass + public static void beforeAll() throws IOException { + client.collections.create(COLLECTION, + collection -> collection + .properties( + Property.text("category"), + Property.integer("price")) + .vectorConfig(VectorConfig.selfProvided())); + + var things = client.collections.use(COLLECTION); + for (var category : List.of("Shoes", "Hat", "Jacket")) { + for (var i = 0; i < 5; i++) { + var vector = randomVector(10, -.1f, .1f); + // For simplicity, the "price" for each items equals to the + // number of characters in the name of the category. + things.data.insert(Map.of( + "category", category, + "price", category.length()), + meta -> meta.vectors(Vectors.of(vector))); + } + } + } + + @Test + public void testOverAll() { + var things = client.collections.use(COLLECTION); + var result = things.aggregate.overAll( + with -> with + .metrics( + Aggregate.integer("price", + calculate -> calculate.median().max().count())) + .includeTotalCount(true)); + + Assertions.assertThat(result) + .as("includes all objects").hasFieldOrPropertyWithValue("totalCount", 15L) + .as("'price' is IntegerAggregation").returns(true, p -> p.isInteger("price")) + .as("aggregated prices").extracting(p -> p.integer("price")) + .as("min").returns(null, IntegerAggregation.Values::min) + .as("max").returns(6L, IntegerAggregation.Values::max) + .as("median").returns(5D, IntegerAggregation.Values::median) + .as("count").returns(15L, IntegerAggregation.Values::count); + } + + @Test + public void testOverAll_groupBy_category() { + var things = client.collections.use(COLLECTION); + var result = things.aggregate.overAll( + with -> with + .metrics( + Aggregate.integer("price", + calculate -> calculate.min().max().count())) + .includeTotalCount(true), + GroupBy.property("category")); + + Assertions.assertThat(result) + .extracting(AggregateResponseGrouped::groups) + .asInstanceOf(InstanceOfAssertFactories.list(AggregateResponseGroup.class)) + .as("group per category").hasSize(3) + .allSatisfy(group -> { + Assertions.assertThat(group) + .extracting(AggregateResponseGroup::groupedBy) + .as(group.groupedBy().property() + " is Text property").returns(true, GroupedBy::isText); + + String category = group.groupedBy().text(); + var expectedPrice = (long) category.length(); + + Function> desc = (String metric) -> { + return () -> "%s ('%s'.length)".formatted(metric, category); + }; + + Assertions.assertThat(group) + .as("'price' is IntegerAggregation").returns(true, g -> g.isInteger("price")) + .as("aggregated prices").extracting(g -> g.integer("price")) + .as(desc.apply("max")).returns(expectedPrice, IntegerAggregation.Values::max) + .as(desc.apply("min")).returns(expectedPrice, IntegerAggregation.Values::min) + .as(desc.apply("count")).returns(5L, IntegerAggregation.Values::count); + }); + } + + @Test + public void testNearVector() { + var things = client.collections.use(COLLECTION); + var result = things.aggregate.nearVector( + randomVector(10, -1f, 1f), + near -> near.limit(5), + with -> with + .metrics( + Aggregate.integer("price", + calculate -> calculate.min().max().count())) + .objectLimit(4) + .includeTotalCount(true)); + + Assertions.assertThat(result) + .as("includes all objects").hasFieldOrPropertyWithValue("totalCount", 4L) + .as("'price' is IntegerAggregation").returns(true, p -> p.isInteger("price")) + .as("aggregated prices").extracting(p -> p.integer("price")) + .as("count").returns(4L, IntegerAggregation.Values::count); + } + + @Test + public void testNearVector_groupBy_category() { + var things = client.collections.use(COLLECTION); + var result = things.aggregate.nearVector( + randomVector(10, -1f, 1f), + near -> near.distance(2f), + with -> with + .metrics( + Aggregate.integer("price", + calculate -> calculate.min().max().median())) + .objectLimit(9) + .includeTotalCount(true), + GroupBy.property("category")); + + Assertions.assertThat(result) + .extracting(AggregateResponseGrouped::groups) + .asInstanceOf(InstanceOfAssertFactories.list(AggregateResponseGroup.class)) + .as("group per category").hasSize(3) + .allSatisfy(group -> { + Assertions.assertThat(group) + .extracting(AggregateResponseGroup::groupedBy) + .as(group.groupedBy().property() + " is Text property").returns(true, GroupedBy::isText); + + String category = group.groupedBy().text(); + var expectedPrice = (long) category.length(); + + Function> desc = (String metric) -> { + return () -> "%s ('%s'.length)".formatted(metric, category); + }; + + Assertions.assertThat(group) + .as("'price' is IntegerAggregation").returns(true, g -> g.isInteger("price")) + .as("aggregated prices").extracting(g -> g.integer("price")) + .as(desc.apply("max")).returns(expectedPrice, IntegerAggregation.Values::max) + .as(desc.apply("min")).returns(expectedPrice, IntegerAggregation.Values::min) + .as(desc.apply("median")).returns((double) expectedPrice, IntegerAggregation.Values::median); + }); + } + + @Test + public void testCollestionSizeShortcut() { + var things = client.collections.use(COLLECTION); + var countAggregate = things.aggregate + .overAll(x -> x.includeTotalCount(true)).totalCount(); + var size = things.size(); + Assertions.assertThat(size).isEqualTo(countAggregate); + } +} diff --git a/src/it/java/io/weaviate/integration/AliasITest.java b/src/it/java/io/weaviate/integration/AliasITest.java new file mode 100644 index 000000000..eb5bca8eb --- /dev/null +++ b/src/it/java/io/weaviate/integration/AliasITest.java @@ -0,0 +1,69 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.List; + +import org.assertj.core.api.Assertions; +import org.junit.BeforeClass; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.alias.Alias; +import io.weaviate.containers.Container; +import io.weaviate.containers.Weaviate; + +public class AliasITest extends ConcurrentTest { + private static final WeaviateClient client = Container.WEAVIATE.getClient(); + + @BeforeClass + public static void __() { + Weaviate.Version.V132.orSkip(); + } + + @Test + public void test_aliasLifecycle() throws IOException { + // Arrange + var nsPaulHewson = ns("PaulHewson"); + var nsGeorgeBarnes = ns("GeorgeBarnes"); + var nsColsonBaker = ns("ColsonBaker"); + + for (var collection : List.of(nsPaulHewson, nsGeorgeBarnes, nsColsonBaker)) { + client.collections.create(collection); + } + + // Act: create aliases + client.alias.create(nsPaulHewson, "Bono"); + client.alias.create(nsGeorgeBarnes, "MachineGunKelly"); + + // Assert: list all + var aliases = client.alias.list(); + Assertions.assertThat(aliases).hasSize(2); + Assertions.assertThat(aliases) + .as("created Bono and MachineGunKelly aliases") + .contains( + new Alias(nsPaulHewson, "Bono"), + new Alias(nsGeorgeBarnes, "MachineGunKelly")); + + // Act: update aliases + client.alias.update("MachineGunKelly", nsColsonBaker); + + // Assert: check MGK points to another collection + var mgk = client.alias.get("MachineGunKelly"); + Assertions.assertThat(mgk).get() + .as("updated MachineGunKelly alias") + .returns(nsColsonBaker, Alias::collection); + + // Act: delete Bono alias + var deleted = client.alias.delete("Bono"); + Assertions.assertThat(deleted).as("object was deleted").isTrue(); + + // Act: delete non-existent alias + deleted = client.alias.delete("Bono"); + Assertions.assertThat(deleted).as("object wasn't deleted").isFalse(); + var paulHewsonAliases = client.alias.list(all -> all.collection(nsPaulHewson)); + Assertions.assertThat(paulHewsonAliases) + .as("no aliases once Bono is deleted") + .isEmpty(); + } +} diff --git a/src/it/java/io/weaviate/integration/BackupITest.java b/src/it/java/io/weaviate/integration/BackupITest.java new file mode 100644 index 000000000..c540afaae --- /dev/null +++ b/src/it/java/io/weaviate/integration/BackupITest.java @@ -0,0 +1,255 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeoutException; +import java.util.stream.IntStream; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.backup.Backup; +import io.weaviate.client6.v1.api.backup.BackupStatus; +import io.weaviate.client6.v1.api.backup.CompressionLevel; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.containers.Weaviate; + +public class BackupITest extends ConcurrentTest { + private static final WeaviateClient client = Weaviate.custom() + .withFilesystemBackup("/tmp/backups").build() + .getClient(); + + @Test + public void test_lifecycle() throws IOException, TimeoutException { + Weaviate.Version.V132.orSkip(); // List backups not implemented in earlier versions + + // Arrange + String nsA = ns("A"), nsB = ns("B"), nsC = ns("C"), nsBig = ns("Big"); + String backup_1 = ns("backup_1").toLowerCase(); + String backend = "filesystem"; + + // Start writing data in the background so it's ready + // by the time we get to backup #3. + var spam = spamData(nsBig); + + client.collections.create(nsA); + client.collections.create(nsB); + client.collections.create(nsC); + + // Insert some data to check restore later + var collectionA = client.collections.use(nsA); + collectionA.data.insert(Map.of()); + + // Act: start backup + var started = client.backup.create(backup_1, backend, + backup -> backup + .includeCollections(nsA, nsB) + .compressionLevel(CompressionLevel.BEST_SPEED)); + + // Assert + Assertions.assertThat(started) + .as("created backup operation") + .returns(backup_1, Backup::id) + .returns(backend, Backup::backend) + .returns(BackupStatus.STARTED, Backup::status) + .returns(null, Backup::error) + .extracting(Backup::includesCollections, InstanceOfAssertFactories.list(String.class)) + .containsOnly(nsA, nsB); + + // Act: await backup competion + var completed = started.waitForCompletion(client); + + // Assert + Assertions.assertThat(completed) + .as("await backup completion") + .returns(backup_1, Backup::id) + .returns(backend, Backup::backend) + .returns(BackupStatus.SUCCESS, Backup::status) + .returns(null, Backup::error); + + // Act: create another backup + String backup_2 = ns("backup_2").toLowerCase(); + client.backup.create(backup_2, backend).waitForCompletion(client); + + // Assert: check the second backup is created successfully + var status_2 = client.backup.getCreateStatus(backup_2, backend); + Assertions.assertThat(status_2).as("backup #2").get() + .returns(BackupStatus.SUCCESS, Backup::status); + + // Act: create and cancel + // Try to throttle this backup by creating a lot of objects, + // limiting CPU resources and requiring high compression ratio. + // This is to avoid flaky tests and make sure we can cancel + // the backup before it completes successfully. + String backup_3 = ns("backup_3").toLowerCase(); + spam.join(); + var cancelMe = client.backup.create(backup_3, backend, + backup -> backup + .includeCollections(nsA, nsB, nsC, nsBig) + .cpuPercentage(1) + .compressionLevel(CompressionLevel.BEST_COMPRESSION)); + cancelMe.cancel(client); + cancelMe.waitForStatus(client, BackupStatus.CANCELED, wait -> wait.interval(500)); + + // Assert: check the backup is cancelled + var status_3 = client.backup.getCreateStatus(backup_3, backend); + Assertions.assertThat(status_3).as("backup #3").get() + .returns(BackupStatus.CANCELED, Backup::status); + + // Assert: all 3 backups are present + var all = client.backup.list(backend, bu -> bu.sortByStartingTimeAsc(true)); + Assertions.assertThat(all).as("all backups") + .extracting(Backup::id) + .containsExactly(backup_1, backup_2, backup_3); + + // Act: delete data and restore backup #1 + client.collections.delete(nsA); + client.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA)); + + // Assert: object inserted in the beginning of the test is present + var restore_1 = client.backup.getRestoreStatus(backup_1, backend) + .orElseThrow().waitForCompletion(client); + Assertions.assertThat(restore_1).as("restore backup #1") + .returns(BackupStatus.SUCCESS, Backup::status); + Assertions.assertThat(collectionA.size()).as("after restore backup #1").isEqualTo(1); + } + + @Test + public void test_lifecycle_async() throws ExecutionException, InterruptedException, Exception { + Weaviate.Version.V132.orSkip(); // List backups not implemented in earlier versions + + // Arrange + String nsA = ns("A"), nsB = ns("B"), nsC = ns("C"), nsBig = ns("Big"); + String backup_1 = ns("backup_1").toLowerCase(); + String backend = "filesystem"; + + try (final var async = client.async()) { + // Start writing data in the background so it's ready + // by the time we get to backup #3. + var spam = spamData(nsBig); + + CompletableFuture.allOf( + async.collections.create(nsA), + async.collections.create(nsB), + async.collections.create(nsC)) + .join(); + + // Insert some data to check restore later + var collectionA = async.collections.use(nsA); + collectionA.data.insert(Map.of()).join(); + + // Act: start backup + var started = async.backup.create(backup_1, backend, + backup -> backup + .includeCollections(nsA, nsB) + .compressionLevel(CompressionLevel.BEST_SPEED)) + .join(); + + // Assert + Assertions.assertThat(started) + .as("created backup operation") + .returns(backup_1, Backup::id) + .returns(backend, Backup::backend) + .returns(BackupStatus.STARTED, Backup::status) + .returns(null, Backup::error) + .extracting(Backup::includesCollections, InstanceOfAssertFactories.list(String.class)) + .containsOnly(nsA, nsB); + + // Act: await backup competion + var completed = started.waitForCompletion(async).join(); + + // Assert + Assertions.assertThat(completed) + .as("await backup completion") + .returns(backup_1, Backup::id) + .returns(backend, Backup::backend) + .returns(BackupStatus.SUCCESS, Backup::status) + .returns(null, Backup::error); + + // Act: create another backup + String backup_2 = ns("backup_2").toLowerCase(); + async.backup.create(backup_2, backend) + .thenCompose(bak -> bak.waitForCompletion(async)) + .join(); + + // Assert: check the second backup is created successfully + var status_2 = async.backup.getCreateStatus(backup_2, backend).join(); + Assertions.assertThat(status_2).as("backup #2").get() + .returns(BackupStatus.SUCCESS, Backup::status); + + // Act: create and cancel + // Try to throttle this backup by creating a lot of objects, + // limiting CPU resources and requiring high compression ratio. + // This is to avoid flaky tests and make sure we can cancel + // the backup before it completes successfully. + String backup_3 = ns("backup_3").toLowerCase(); + spam.join(); + async.backup.create(backup_3, backend, + backup -> backup + .includeCollections(nsA, nsB, nsC, nsBig) + .cpuPercentage(1) + .compressionLevel(CompressionLevel.BEST_COMPRESSION)) + .thenCompose(cancelMe -> cancelMe.cancel(async) + .thenCompose(__ -> cancelMe.waitForStatus(async, BackupStatus.CANCELED, + wait -> wait.interval(500)))) + .join(); + + // Assert: check the backup is cancelled + var status_3 = async.backup.getCreateStatus(backup_3, backend).join(); + Assertions.assertThat(status_3).as("backup #3").get() + .returns(BackupStatus.CANCELED, Backup::status); + + // Assert: all 3 backups are present + var all = async.backup.list(backend).join(); + Assertions.assertThat(all).as("all backups") + .extracting(Backup::id) + .contains(backup_1, backup_2, backup_3); + + // Act: delete data and restore backup #1 + async.collections.delete(nsA).join(); + async.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA)).join(); + + // Assert: object inserted in the beginning of the test is present + var restore_1 = async.backup.getRestoreStatus(backup_1, backend) + .thenCompose(bak -> bak.orElseThrow().waitForCompletion(async)) + .join(); + Assertions.assertThat(restore_1).as("restore backup #1") + .returns(BackupStatus.SUCCESS, Backup::status); + Assertions.assertThat(collectionA.size().join()).as("after restore backup #1").isEqualTo(1); + } + } + + @Test(expected = IllegalStateException.class) + public void test_waitForCompletion_unknown() throws IOException, TimeoutException { + var backup = new Backup("#1", "/tmp/bak/#1", "filesystem", List.of("Things"), BackupStatus.STARTED, + null, null, null, null, null); + backup.waitForCompletion(client); + } + + /** Write 10_000 entries with a UUID[10] property. */ + private CompletableFuture spamData(String collectionName) { + return CompletableFuture.supplyAsync(() -> { + try { + client.collections.create(collectionName, + c -> c.properties(Property.uuidArray("uuids"))); + + var spam = client.collections.use(collectionName); + for (int i = 0; i < 10_000; i++) { + var uuids = IntStream.range(0, 10).mapToObj(j -> UUID.randomUUID()).toArray(); + spam.data.insert(Map.of("uuids", uuids)); + } + } catch (IOException e) { + throw new CompletionException(e); + } + return null; + }); + } +} diff --git a/src/it/java/io/weaviate/integration/ClusterITest.java b/src/it/java/io/weaviate/integration/ClusterITest.java new file mode 100644 index 000000000..baea17f70 --- /dev/null +++ b/src/it/java/io/weaviate/integration/ClusterITest.java @@ -0,0 +1,137 @@ +package io.weaviate.integration; + +import java.io.IOException; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.cluster.Node; +import io.weaviate.client6.v1.api.cluster.NodeVerbosity; +import io.weaviate.client6.v1.api.cluster.ShardingState; +import io.weaviate.client6.v1.api.cluster.replication.Replication; +import io.weaviate.client6.v1.api.cluster.replication.ReplicationState; +import io.weaviate.client6.v1.api.cluster.replication.ReplicationType; +import io.weaviate.containers.Weaviate; +import io.weaviate.containers.Weaviate.Version; + +public class ClusterITest extends ConcurrentTest { + private static final WeaviateClient client = Weaviate.cluster(3).getClient(); + + @Test + public void test_shardingState() throws IOException { + // Arrange + var nsA = ns("A"); + var nsB = ns("B"); + + client.collections.create(nsA, + a -> a.replication(r -> r.replicationFactor(2))); + client.collections.create(nsB, + b -> b.replication(r -> r.replicationFactor(3))); + + // Act + var optShardsA = client.cluster.shardingState(nsA); + var optShardsB = client.cluster.shardingState(nsB); + + // Assert + var shardsA = Assertions.assertThat(optShardsA).get() + .returns(nsA, ShardingState::collection) + .extracting(ShardingState::shards) + .actual(); + + var shardsB = Assertions.assertThat(optShardsB).get() + .returns(nsB, ShardingState::collection) + .extracting(ShardingState::shards) + .actual(); + + Assertions.assertThat(shardsA).doesNotContainAnyElementsOf(shardsB); + } + + @Test + public void test_listNodes() throws IOException { + // Act + var allNodes = client.cluster.listNodes(); + + // Assert + Assertions.assertThat(allNodes).as("total no. nodes").hasSize(3); + } + + @Test + public void test_replicateLifecycle() throws IOException { + Version.V132.orSkip(); + + // Arrange + + // We must create the collection first before any shards exist on the nodes. + var nsThings = ns("Things"); + client.collections.create(nsThings); + + var nodes = client.cluster.listNodes(opt -> opt.verbosity(NodeVerbosity.VERBOSE)); + Assertions.assertThat(nodes) + .as("cluster at least 2 nodes").hasSizeGreaterThanOrEqualTo(2); + + Node source = null; + Node target = null; + for (var node : nodes) { + if (source == null && !node.shards().isEmpty()) { + source = node; + } else if (target == null) { + target = node; + } + } + + var wantShard = source.shards().get(0).name(); + var srcNode = source.name(); + var tgtNode = target.name(); + + // Act: start replication + var replication = client.cluster.replicate( + nsThings, + wantShard, + srcNode, + tgtNode, + ReplicationType.MOVE); + + var got = client.cluster.replication.get(replication.uuid()); + Assertions.assertThat(got).get() + .as("expected replication status") + .returns(nsThings, Replication::collection) + .returns(wantShard, Replication::shard) + .returns(srcNode, Replication::sourceNode) + .returns(tgtNode, Replication::targetNode) + .returns(ReplicationType.MOVE, Replication::type) + .returns(null, Replication::history) + .extracting(Replication::status).isNotNull(); + + var withHistory = client.cluster.replication.get( + replication.uuid(), + repl -> repl.includeHistory(true)); + Assertions.assertThat(withHistory).get() + .as("includes history") + .extracting(Replication::history).isNotNull(); + + // Act: query replications + var filtered = client.cluster.replication.list( + repl -> repl + .collection(nsThings) + .shard(wantShard) + .targetNode(tgtNode)); + + Assertions.assertThat(filtered) + .as("existing replications for %s-%s -> %s", nsThings, wantShard, tgtNode) + .hasSize(1); + + // Act: cancel + client.cluster.replication.cancel(replication.uuid()); + + eventually(() -> client.cluster.replication.get(replication.uuid()) + .orElseThrow() + .status().state() == ReplicationState.CANCELED, 1000, 25, "replication must be canceled"); + + // Act: delete replication + client.cluster.replication.delete(replication.uuid()); + + eventually(() -> client.cluster.replication.list().isEmpty(), 1000, 15, "replication must be deleted"); + } +} diff --git a/src/it/java/io/weaviate/integration/CollectionsITest.java b/src/it/java/io/weaviate/integration/CollectionsITest.java new file mode 100644 index 000000000..8d68bb1c6 --- /dev/null +++ b/src/it/java/io/weaviate/integration/CollectionsITest.java @@ -0,0 +1,331 @@ +package io.weaviate.integration; + +import java.io.IOException; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.DataType; +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.InvertedIndex; +import io.weaviate.client6.v1.api.collections.ObjectTtl; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.Replication; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.config.Shard; +import io.weaviate.client6.v1.api.collections.config.ShardStatus; +import io.weaviate.client6.v1.api.collections.generative.DummyGenerative; +import io.weaviate.client6.v1.api.collections.query.BaseQueryOptions; +import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw; +import io.weaviate.client6.v1.api.collections.vectorizers.SelfProvidedVectorizer; +import io.weaviate.containers.Container; +import io.weaviate.containers.Weaviate; + +public class CollectionsITest extends ConcurrentTest { + private static WeaviateClient client = Container.WEAVIATE.getClient(); + + @Test + public void testCreateGetDelete() throws IOException { + var collectionName = ns("Things"); + client.collections.create(collectionName, + col -> col + .properties(Property.text("username"), Property.integer("age")) + .vectorConfig(VectorConfig.selfProvided())); + + var thingsCollection = client.collections.getConfig(collectionName); + + Assertions.assertThat(thingsCollection).get() + .hasFieldOrPropertyWithValue("collectionName", collectionName) + .extracting(CollectionConfig::vectors, InstanceOfAssertFactories.map(String.class, VectorConfig.class)) + .as("default vector").extractingByKey("default") + .satisfies(defaultVector -> { + Assertions.assertThat(defaultVector) + .as("has none vectorizer").isInstanceOf(SelfProvidedVectorizer.class); + Assertions.assertThat(defaultVector).extracting(VectorConfig::vectorIndex) + .isInstanceOf(Hnsw.class); + }); + + client.collections.delete(collectionName); + var noCollection = client.collections.getConfig(collectionName); + Assertions.assertThat(noCollection).as("after delete").isEmpty(); + } + + @Test + public void testCrossReferences() throws IOException { + // Arrange: Create Owners collection + var nsOwners = ns("Owners"); + client.collections.create(nsOwners); + + // Act: Create Things collection with owner -> owners + var nsThings = ns("Things"); + client.collections.create(nsThings, + col -> col.references(ReferenceProperty.to("ownedBy", nsOwners))); + var things = client.collections.use(nsThings); + + // Assert: Things --ownedBy-> Owners + Assertions.assertThat(things.config.get()) + .as("after create Things").get() + .satisfies(c -> { + Assertions.assertThat(c.references()) + .as("ownedBy").filteredOn(p -> p.propertyName().equals("ownedBy")).first() + .extracting(p -> p.dataTypes(), InstanceOfAssertFactories.LIST) + .containsOnly(nsOwners); + }); + + // Arrange: Create OnlineStores and Markets collections + var nsOnlineStores = ns("OnlineStores"); + client.collections.create(nsOnlineStores); + + var nsMarkets = ns("Markets"); + client.collections.create(nsMarkets); + + // Act: Update Things collections to add polymorphic reference + things.config.addReference("soldIn", nsOnlineStores, nsMarkets); + + // Assert: Things --soldIn-> [OnlineStores, Markets] + Assertions.assertThat(things.config.get()) + .as("after add property").get() + .satisfies(c -> { + Assertions.assertThat(c.references()) + .as("soldIn").filteredOn(p -> p.propertyName().equals("soldIn")).first() + .extracting(p -> p.dataTypes(), InstanceOfAssertFactories.LIST) + .containsOnly(nsOnlineStores, nsMarkets); + }); + } + + @Test + public void testListDeleteAll() throws Exception { + // Use a separate container for this test so as not to interfere + // with other tests. + try (final var _client = Weaviate.createDefault().getBareClient()) { + var nsA = ns("A"); + var nsB = ns("B"); + var nsC = ns("C"); + + _client.collections.create(nsA); + _client.collections.create(nsB); + _client.collections.create(nsC); + + Assertions.assertThat(_client.collections.exists(nsA)).isTrue(); + Assertions.assertThat(_client.collections.exists(nsB)).isTrue(); + Assertions.assertThat(_client.collections.exists(nsC)).isTrue(); + Assertions.assertThat(_client.collections.exists(ns("X"))).isFalse(); + + var all = _client.collections.list(); + Assertions.assertThat(all) + .hasSizeGreaterThanOrEqualTo(3) + .extracting(CollectionConfig::collectionName) + .contains(nsA, nsB, nsC); + + _client.collections.deleteAll(); + + all = _client.collections.list(); + Assertions.assertThat(all.isEmpty()); + } + } + + @Test + public void testUpdateCollection() throws IOException { + var nsBoxes = ns("Boxes"); + var nsThings = ns("Things"); + + client.collections.create(nsBoxes); + + client.collections.create(nsThings, + collection -> collection + .description("Things stored in boxes") + .properties( + Property.text("name"), + Property.integer("width", + w -> w.description("how wide this thing is"))) + .invertedIndex(idx -> idx.cleanupIntervalSeconds(10)) + .replication(repl -> repl.asyncEnabled(true))); + + var things = client.collections.use(nsThings); + + // Act + things.config.update(c -> c + .description("Things stored on shelves") + .propertyDescription("width", "not height") + .invertedIndex(idx -> idx.cleanupIntervalSeconds(30)) + .replication(repl -> repl.asyncEnabled(false))); + + // Assert + var updated = things.config.get(); + Assertions.assertThat(updated).get() + .returns("Things stored on shelves", CollectionConfig::description) + .satisfies(collection -> { + Assertions.assertThat(collection) + .extracting(CollectionConfig::properties, InstanceOfAssertFactories.list(Property.class)) + .extracting(Property::description).contains("not height"); + + Assertions.assertThat(collection) + .extracting(CollectionConfig::invertedIndex).returns(30, InvertedIndex::cleanupIntervalSeconds); + + Assertions.assertThat(collection) + .extracting(CollectionConfig::replication).returns(false, Replication::asyncEnabled); + }); + } + + @Test + public void testShards() throws IOException { + var nsShatteredCups = ns("ShatteredCups"); + client.collections.create(nsShatteredCups); + var cups = client.collections.use(nsShatteredCups); + + // Act: get initial shard state + var shards = cups.config.getShards(); + + Assertions.assertThat(shards).as("single-tenant collections has 1 shard").hasSize(1); + var singleShard = shards.get(0); + + // Act: flip the status + var wantStatus = singleShard.status().equals("READY") ? ShardStatus.READONLY : ShardStatus.READY; + var updated = cups.config.updateShards(wantStatus, singleShard.name()); + + Assertions.assertThat(updated) + .as("shard status changed") + .hasSize(1) + .extracting(Shard::status) + .containsOnly(wantStatus.name()); + } + + @Test(expected = WeaviateApiException.class) + public void testInvalidCollectionName() throws IOException { + client.collections.create("^collection@weaviate.io$"); + } + + @Test + public void testNestedProperties() throws IOException { + var nsBuildings = ns("Buildings"); + + client.collections.create( + nsBuildings, c -> c.properties( + Property.object("address", p -> p.nestedProperties( + Property.text("street"), + Property.integer("building_nr"), + Property.bool("isOneWay"))), + Property.objectArray("apartments", p -> p.nestedProperties( + Property.integer("door_nr"), + Property.number("area"))))); + + var config = client.collections.getConfig(nsBuildings); + + var properties = Assertions.assertThat(config).get() + .extracting(CollectionConfig::properties, InstanceOfAssertFactories.list(Property.class)) + .hasSize(2).actual(); + + Assertions.assertThat(properties.get(0)) + .returns("address", Property::propertyName) + .returns(DataType.OBJECT, p -> p.dataTypes().get(0)) + .extracting(Property::nestedProperties, InstanceOfAssertFactories.list(Property.class)) + .extracting(Property::dataTypes).extracting(types -> types.get(0)) + .containsExactly(DataType.TEXT, DataType.INT, DataType.BOOL); + + Assertions.assertThat(properties.get(1)) + .returns("apartments", Property::propertyName) + .returns(DataType.OBJECT_ARRAY, p -> p.dataTypes().get(0)) + .extracting(Property::nestedProperties, InstanceOfAssertFactories.list(Property.class)) + .extracting(Property::dataTypes).extracting(types -> types.get(0)) + .containsExactly(DataType.INT, DataType.NUMBER); + } + + @Test + public void test_updateQuantization_uncompressed() throws IOException { + // Arrange + var nsThings = ns("Things"); + + var things = client.collections.create(nsThings, + c -> c.vectorConfig(VectorConfig.selfProvided( + self -> self.quantization(Quantization.uncompressed())))); + + // Act + things.config.update( + c -> c.vectorConfig(VectorConfig.selfProvided( + self -> self.quantization(Quantization.bq())))); + + // Assert + var config = things.config.get(); + Assertions.assertThat(config).get() + .extracting(CollectionConfig::vectors) + .extracting("default", InstanceOfAssertFactories.type(VectorConfig.class)) + .extracting(VectorConfig::quantization) + .returns(Quantization.Kind.BQ, Quantization::_kind); + } + + @Test + public void test_updateGenerative() throws IOException { + // Arrange + var nsThings = ns("Things"); + + var things = client.collections.create(nsThings, + c -> c.vectorConfig(VectorConfig.selfProvided())); + + // Act + things.config.update(c -> c.generativeModule(new DummyGenerative())); + + // Assert + var config = things.config.get(); + Assertions.assertThat(config).get() + .extracting(CollectionConfig::generativeModule).isNotNull() + .returns(Generative.Kind.DUMMY, Generative::_kind); + } + + @Test + public void test_objectTtl() throws IOException { + Weaviate.Version.V135.orSkip(); + + // Arrange + var nsThings = ns("Things"); + + // Act: create collection + var things = client.collections.create(nsThings, + c -> c.objectTtl(ttl -> ttl + .deleteByCreationTime() + .defaultTtlSeconds(120))); + + // Assert: correct Object TTL config + var created = things.config.get(); + + Assertions.assertThat(created).get() + .as("created collection") + .extracting(CollectionConfig::objectTtl).isNotNull() + .returns(true, ObjectTtl::enabled) + .returns(BaseQueryOptions.CREATION_TIME_PROPERTY, ObjectTtl::deleteOn) + .returns(120, ObjectTtl::defaultTtlSeconds); + + // Act: update TTL config + things.config.update( + c -> c.objectTtl(ttl -> ttl + .deleteByUpdateTime() + .defaultTtlSeconds(400))); + + // Assert: correct Object TTL config + var updated = things.config.get(); + + Assertions.assertThat(updated).get() + .as("updated collection") + .extracting(CollectionConfig::objectTtl).isNotNull() + .returns(true, ObjectTtl::enabled) + .returns(BaseQueryOptions.LAST_UPDATE_TIME_PROPERTY, ObjectTtl::deleteOn) + .returns(400, ObjectTtl::defaultTtlSeconds); + + // Act: disable TTL config + things.config.update(c -> c.objectTtl(ttl -> ttl.enabled(false))); + + // Assert: correct Object TTL config + var disabled = things.config.get(); + + Assertions.assertThat(disabled).get() + .as("disabled object TTL") + .extracting(CollectionConfig::objectTtl).isNotNull() + .returns(false, ObjectTtl::enabled); + } +} diff --git a/src/it/java/io/weaviate/integration/DataITest.java b/src/it/java/io/weaviate/integration/DataITest.java new file mode 100644 index 000000000..a0969655f --- /dev/null +++ b/src/it/java/io/weaviate/integration/DataITest.java @@ -0,0 +1,559 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.time.OffsetDateTime; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.data.BatchReference; +import io.weaviate.client6.v1.api.collections.data.DeleteManyResponse; +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.api.collections.query.Metadata; +import io.weaviate.client6.v1.api.collections.query.Metadata.MetadataField; +import io.weaviate.client6.v1.api.collections.query.QueryReference; +import io.weaviate.client6.v1.api.collections.tenants.Tenant; +import io.weaviate.containers.Container; + +public class DataITest extends ConcurrentTest { + private static final WeaviateClient client = Container.WEAVIATE.getClient(); + private static final String COLLECTION = unique("Artists"); + private static final String VECTOR_INDEX = "bring_your_own"; + + @BeforeClass + public static void beforeAll() throws IOException { + createTestCollections(); + } + + @Test + public void testCreateGetDelete() throws IOException { + var artists = client.collections.use(COLLECTION); + var id = randomUUID(); + float[] vector = { 1, 2, 3 }; + + artists.data.insert(Map.of("name", "john doe"), + metadata -> metadata + .uuid(id) + .vectors(Vectors.of(VECTOR_INDEX, vector))); + + var object = artists.query.fetchObjectById(id, query -> query + .returnProperties("name") + .returnMetadata( + MetadataField.VECTOR, + Metadata.CREATION_TIME_UNIX, Metadata.LAST_UPDATE_TIME_UNIX)); + + Assertions.assertThat(artists.data.exists(id)) + .as("object exists after insert").isTrue(); + Assertions.assertThat(object) + .as("object has correct properties").get() + .satisfies(obj -> { + Assertions.assertThat(obj.uuid()) + .as("object id").isEqualTo(id); + + Assertions.assertThat(obj.vectors().getSingle(VECTOR_INDEX)) + .containsExactly(vector); + + Assertions.assertThat(obj.properties()) + .as("has expected properties") + .containsEntry("name", "john doe"); + + Assertions.assertThat(obj.createdAt()) + .as("createdAt").isNotNull(); + Assertions.assertThat(obj.lastUpdatedAt()) + .as("lastUpdatedAt").isNotNull(); + }); + + var deleted = artists.data.deleteById(id); + Assertions.assertThat(deleted) + .as("object was deleted").isTrue(); + Assertions.assertThat(artists.data.exists(id)) + .as("object not exists after deletion").isFalse(); + + deleted = artists.data.deleteById(id); + + // TODO: Change to isFalse() after fixed in Weaviate server + Assertions.assertThat(deleted) + .as("object wasn't deleted").isTrue(); + } + + @Test + public void testBlobData() throws IOException { + var nsCats = ns("Cats"); + + client.collections.create(nsCats, + collection -> collection.properties( + Property.text("breed"), + Property.blob("img"))); + + var cats = client.collections.use(nsCats); + var ragdollPng = EncodedMedia.IMAGE; + var ragdoll = cats.data.insert(Map.of( + "breed", "ragdoll", + "img", ragdollPng)); + + var got = cats.query.fetchObjectById(ragdoll.uuid(), + cat -> cat.returnProperties("img")); + + Assertions.assertThat(got).get() + .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .extractingByKey("img").isEqualTo(ragdollPng); + } + + private static void createTestCollections() throws IOException { + var awardsGrammy = unique("Grammy"); + client.collections.create(awardsGrammy); + + var awardsOscar = unique("Oscar"); + client.collections.create(awardsOscar); + + client.collections.create(COLLECTION, + col -> col + .properties( + Property.text("name"), + Property.integer("age")) + .references( + ReferenceProperty.to("hasAwards", awardsGrammy, awardsOscar)) + .vectorConfig(VectorConfig.selfProvided(VECTOR_INDEX))); + } + + @Test + public void testReferences_AddReplaceDelete() throws IOException { + // Arrange + var nsPersons = ns("Person"); + + client.collections.create(nsPersons, + collection -> collection + .properties(Property.text("name")) + .references(ReferenceProperty.to("hasFriend", nsPersons))); + + var persons = client.collections.use(nsPersons); + var john = persons.data.insert(Map.of("name", "john")); + var albie = persons.data.insert(Map.of("name", "albie")); + + // Act: add reference + persons.data.referenceAdd( + john.uuid(), + "hasFriend", + ObjectReference.object(albie)); + + // Assert + var johnWithFriends = persons.query.fetchObjectById(john.uuid(), + query -> query.returnReferences( + QueryReference.single("hasFriend", + friend -> friend.returnProperties("name")))); + + Assertions.assertThat(johnWithFriends).get() + .as("friends after ADD") + .extracting(WeaviateObject::references).extracting("hasFriend") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + .hasSize(1) + .first().extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .returns("albie", friend -> friend.get("name")); + + // Act: replace reference + var barbara = persons.data.insert(Map.of("name", "barbara")); + persons.data.referenceReplace( + john.uuid(), + "hasFriend", + ObjectReference.object(barbara)); + + johnWithFriends = persons.query.fetchObjectById(john.uuid(), + query -> query.returnReferences( + QueryReference.single("hasFriend", + friend -> friend.returnProperties("name")))); + + Assertions.assertThat(johnWithFriends).get() + .as("friends after REPLACE") + .extracting(WeaviateObject::references).extracting("hasFriend") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + .hasSize(1) + .first().extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .returns("barbara", friend -> friend.get("name")); + + // Act: delete reference + persons.data.referenceDelete( + john.uuid(), + "hasFriend", + ObjectReference.object(barbara)); + + // Assert + johnWithFriends = persons.query.fetchObjectById(john.uuid(), + query -> query.returnReferences( + QueryReference.single("hasFriend"))); + + Assertions.assertThat(johnWithFriends).get() + .as("friends after DELETE") + .extracting(WeaviateObject::references).extracting("hasFriend") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + .isEmpty(); + } + + @Test + public void testReplace() throws IOException { + // Arrange + var nsBooks = ns("Books"); + + client.collections.create(nsBooks, + collection -> collection + .properties(Property.text("title"), Property.integer("year"))); + + // Add 1 book with 'title' only. + var books = client.collections.use(nsBooks); + var ivanhoe = books.data.insert(Map.of("title", "ivanhoe")); + + // Act + books.data.replace(ivanhoe.uuid(), + replace -> replace.properties(Map.of("year", 1819))); + + // Assert + var replacedIvanhoe = books.query.fetchObjectById(ivanhoe.uuid()); + + Assertions.assertThat(replacedIvanhoe).get() + .as("has ONLY year property") + .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .doesNotContain(Map.entry("title", "ivanhoe")) + .contains(Map.entry("year", 1819L)); + } + + @Test + public void testUpdate() throws IOException { + // Arrange + var nsBooks = ns("Books"); + var nsAuthors = ns("Authors"); + + client.collections.create(nsAuthors, + collection -> collection + .properties(Property.text("name"))); + + client.collections.create(nsBooks, + collection -> collection + .properties(Property.text("title"), Property.integer("year")) + .references(ReferenceProperty.to("writtenBy", nsAuthors)) + .vectorConfig(VectorConfig.selfProvided())); + + var authors = client.collections.use(nsAuthors); + var walter = authors.data.insert(Map.of("name", "walter scott")); + + var vector = new float[] { 1, 2, 3 }; + + var books = client.collections.use(nsBooks); + + // Add 1 book without mentioning its author, year published, + // or supplying a vector. + var ivanhoe = books.data.insert(Map.of("title", "ivanhoe")); + + // Act + books.data.update(ivanhoe.uuid(), + update -> update + .properties(Map.of("year", 1819)) + .reference("writtenBy", ObjectReference.objects(walter)) + .vectors(Vectors.of(vector))); + + // Assert + var updIvanhoe = books.query.fetchObjectById( + ivanhoe.uuid(), + query -> query + .includeVector() + .returnReferences(QueryReference.single("writtenBy"))); + + Assertions.assertThat(updIvanhoe).get() + .satisfies(book -> { + Assertions.assertThat(book) + .as("has both year and title property") + .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .contains(Map.entry("title", "ivanhoe"), Map.entry("year", 1819L)); + + Assertions.assertThat(book) + .as("has reference to Authors") + .extracting(WeaviateObject::references, InstanceOfAssertFactories.MAP) + .extractingByKey("writtenBy", InstanceOfAssertFactories.list(WeaviateObject.class)) + .first() + .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .contains(Map.entry("name", "walter scott")); + + Assertions.assertThat(book) + .as("has a vector") + .extracting(WeaviateObject::vectors) + .returns(vector, Vectors::getDefaultSingle); + }); + } + + @Test + public void testDeleteMany() throws IOException { + // Arrange + var nsThings = ns("Things"); + + client.collections.create(nsThings, + collection -> collection + .properties(Property.integer("last_used"))); + + var things = client.collections.use(nsThings); + things.data.insert(Map.of("last_used", 1)); + var delete_1 = things.data.insert(Map.of("last_used", 5)).uuid(); + var delete_2 = things.data.insert(Map.of("last_used", 9)).uuid(); + + // Act (dry run) + things.data.deleteMany( + Filter.property("last_used").gte(4), + opt -> opt.dryRun(true)); + + // Assert + Assertions.assertThat(things.data.exists(delete_1)).as("#1 exists").isTrue(); + Assertions.assertThat(things.data.exists(delete_2)).as("#2 exists").isTrue(); + + // Act (live run) + var deleted = things.data.deleteMany( + Filter.property("last_used").gte(4), + opt -> opt.verbose(true)); + + // Assert + Assertions.assertThat(deleted) + .returns(2L, DeleteManyResponse::matches) + .returns(2L, DeleteManyResponse::successful) + .returns(0L, DeleteManyResponse::failed) + .extracting(DeleteManyResponse::objects, InstanceOfAssertFactories.list(DeleteManyResponse.DeletedObject.class)) + .extracting(DeleteManyResponse.DeletedObject::uuid) + .containsOnly(delete_1, delete_2); + + var count = things.aggregate.overAll( + cnt -> cnt + .objectLimit(100) + .includeTotalCount(true)) + .totalCount(); + + Assertions.assertThat(count) + .as("one object remaining") + .isEqualTo(1); + + } + + @Test + public void testInsertMany() throws IOException { + // Arrange + var nsThings = ns("Things"); + + client.collections.create(nsThings); + + var things = client.collections.use(nsThings); + + // Act + things.data.insertMany(Map.of(), Map.of(), Map.of(), Map.of(), Map.of()); + + // Assert + var count = things.aggregate.overAll( + cnt -> cnt + .objectLimit(100) + .includeTotalCount(true)) + .totalCount(); + + Assertions.assertThat(count) + .as("collection has 5 objects") + .isEqualTo(5); + } + + @Test + public void testReferenceAddMany() throws IOException { + // Arrange + var nsCities = ns("Cities"); + var nsAirports = ns("Airports"); + + client.collections.create(nsAirports); + client.collections.create(nsCities, c -> c + .references(ReferenceProperty.to("hasAirports", nsAirports))); + + var airports = client.collections.use(nsAirports); + var cities = client.collections.use(nsCities); + + var alpha = airports.data.insert(Map.of()).uuid(); + var goodburg = cities.data.insert(Map.of(), city -> city + .reference("hasAirports", ObjectReference.uuid(alpha))); + + // Act + var newAirports = airports.data.insertMany(Map.of(), Map.of()); + var bravo = newAirports.responses().get(0).uuid(); + var charlie = newAirports.responses().get(1).uuid(); + + var response = cities.data.referenceAddMany(BatchReference.uuids(goodburg, "hasAirports", bravo, charlie)); + + // Assert + Assertions.assertThat(response.errors()).isEmpty(); + + var goodburgAirports = cities.query.fetchObjectById(goodburg.uuid(), + city -> city.returnReferences( + QueryReference.single("hasAirports"))); + + Assertions.assertThat(goodburgAirports).get() + .as("Goodburg has 3 airports") + .extracting(WeaviateObject::references) + .extracting(references -> references.get("hasAirports"), + InstanceOfAssertFactories.list(WeaviateObject.class)) + .extracting(WeaviateObject::uuid) + .contains(alpha, bravo, charlie); + } + + @Test(expected = WeaviateApiException.class) + public void testDuplicateUuid() throws IOException { + // Arrange + var nsThings = ns("Things"); + + client.collections.create(nsThings); + var things = client.collections.use(nsThings); + var thing_1 = things.data.insert(Map.of()); + + // Act + things.data.insert(Map.of(), thing -> thing.uuid(thing_1.uuid())); + } + + @Test + public void testDataTypes() throws IOException { + // Arrange + var nsDataTypes = ns("DataTypes"); + + // BLOB type is omitted because a base64-encoded image + // isn't doing the failure message any favours. + // It's tested in other test cases above. + client.collections.create( + nsDataTypes, c -> c + .properties( + Property.text("prop_text"), + Property.integer("prop_integer"), + Property.number("prop_number"), + Property.bool("prop_bool"), + Property.date("prop_date"), + Property.uuid("prop_uuid"), + Property.integerArray("prop_integer_array"), + Property.numberArray("prop_number_array"), + Property.boolArray("prop_bool_array"), + Property.dateArray("prop_date_array"), + Property.uuidArray("prop_uuid_array"), + Property.textArray("prop_text_array"), + Property.phoneNumber("prop_phone_number"), + Property.geoCoordinates("prop_geo_coordinates"), + Property.object("prop_object", + p -> p.nestedProperties( + Property.text("marco"))), + Property.objectArray("prop_object_array", + p -> p.nestedProperties( + Property.text("marco"))))); + + var types = client.collections.use(nsDataTypes); + + var now = OffsetDateTime.now(); + var uuid = UUID.randomUUID(); + + Map want = Map.ofEntries( + Map.entry("prop_text", "Hello, World!"), + Map.entry("prop_integer", 1L), + Map.entry("prop_number", 1D), + Map.entry("prop_bool", true), + Map.entry("prop_date", now), + Map.entry("prop_uuid", uuid), + Map.entry("prop_integer_array", List.of(1L, 2L, 3L)), + Map.entry("prop_number_array", List.of(1D, 2D, 3D)), + Map.entry("prop_bool_array", List.of(true, false)), + Map.entry("prop_date_array", List.of(now, now)), + Map.entry("prop_uuid_array", List.of(uuid, uuid)), + Map.entry("prop_text_array", List.of("a", "b", "c")), + Map.entry("prop_phone_number", PhoneNumber.international("+380 95 1433336")), + Map.entry("prop_geo_coordinates", new GeoCoordinates(1f, 2f)), + Map.entry("prop_object", Map.of("marco", "polo")), + Map.entry("prop_object_array", List.of(Map.of("marco", "polo")))); + + // Act + var object = types.data.insert(want); + var got = types.query.fetchObjectById(object.uuid()); // return all properties + + // Assert + Assertions.assertThat(got).get() + .extracting(WeaviateObject::properties) + .asInstanceOf(InstanceOfAssertFactories.map(String.class, Object.class)) + // Most of PhoneNumber fields are only present on read and are null on write. + .usingRecursiveComparison() + .withComparatorForType(ORMITest::comparePhoneNumbers, PhoneNumber.class) + .isEqualTo(want); + } + + record Address( + String street, + @io.weaviate.client6.v1.api.collections.annotations.Property("building_nr") int buildingNr, + @io.weaviate.client6.v1.api.collections.annotations.Property("isOneWay") boolean oneWay) { + } + + @Test + public void testNestedProperties_insertMany() throws IOException { + // Arrange + var nsBuildings = ns("Buildings"); + + client.collections.create( + nsBuildings, c -> c.properties( + Property.object("address", p -> p.nestedProperties( + Property.text("street"), + Property.integer("building_nr"), + Property.bool("isOneWay"))), + Property.objectArray("apartments", p -> p.nestedProperties( + Property.integer("door_nr"), + Property.number("area"))))); + + var buildings = client.collections.use(nsBuildings); + + Map house_1 = Map.of( + "address", Map.of( + "street", "Burggasse", + "building_nr", 51, + "isOneWay", true), + "apartments", List.of( + Map.of("door_nr", 11, "area", 42.2), + Map.of("door_nr", 12, "area", 26.7))); + Map house_2 = Map.of( + "address", new Address( + "Port Mariland St.", + 111, + false), + "apartments", new Map[] { + Map.of("door_nr", 21, "area", 42.2), + Map.of("door_nr", 22, "area", 26.7), + }); + + // Act + var result = buildings.data.insertMany(house_1, house_2); + + // Assert + Assertions.assertThat(result.errors()).isEmpty(); + } + + @Ignore("Making Emails collection multi-tenant causes ReferencesITest::testNestedReferences to fail") + @Test + public void test_multiTenant() throws IOException { + // Arrange + var nsEmails = ns("Emails"); + var emails = client.collections.create(nsEmails, + c -> c.multiTenancy(mt -> mt.enabled(true))); + + var johndoe = "john-doe"; + emails.tenants.create(Tenant.active(johndoe)); + emails = emails.withTenant(johndoe); + + // Act + var inserted = emails.data.insert(Map.of("subject", "McDonald's Xmas Bonanza")); + + // Assert + Assertions.assertThat(inserted).returns(johndoe, WeaviateObject::tenant); + } +} diff --git a/src/it/java/io/weaviate/integration/EncodedMedia.java b/src/it/java/io/weaviate/integration/EncodedMedia.java new file mode 100644 index 000000000..d075de08f --- /dev/null +++ b/src/it/java/io/weaviate/integration/EncodedMedia.java @@ -0,0 +1,6 @@ +package io.weaviate.integration; + +class EncodedMedia { + public static final String IMAGE = "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"; + +} diff --git a/src/it/java/io/weaviate/integration/OIDCSupportITest.java b/src/it/java/io/weaviate/integration/OIDCSupportITest.java new file mode 100644 index 000000000..fbbbd8c67 --- /dev/null +++ b/src/it/java/io/weaviate/integration/OIDCSupportITest.java @@ -0,0 +1,227 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.time.Duration; +import java.util.List; +import java.util.UUID; + +import org.assertj.core.api.Assertions; +import org.junit.Assume; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.Authentication; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.TokenProvider.Token; +import io.weaviate.client6.v1.internal.rest.RestTransport; +import io.weaviate.containers.Weaviate; + +/** + * Test that the client can use one of the supported authentication flows to + * obtain a token from the OIDC provider and use it in a request to Weaviate. + * + * Running this test suite successfully requires talking to external services, + * so tests will be skipped if we don't have internet. See + * {@link #hasInternetConnection}. + * Additionally, {@code WCS_DUMMY_CI_PW} and {@code OKTA_CLIENT_SECRET} + * environment variables must be set. + */ +public class OIDCSupportITest extends ConcurrentTest { + private static final String WCS_DUMMY_CI_USERNAME = "oidc-test-user@weaviate.io"; + private static final String WCS_DUMMY_CI_PW = System.getenv("WCS_DUMMY_CI_PW"); + + /** + * Weaviate container that uses WCS-backed OIDC provider. + * Supports ResourceOwnerPassword and RefreshToken authentication flows. + */ + private static final Weaviate wcsContainer = Weaviate.custom().withOIDC().build(); + + private static final String OKTA_CLIENT_ID = "0oa7e9ipdkVZRUcxo5d7"; + private static final String OKTA_CLIENT_SECRET = System.getenv("OKTA_CLIENT_SECRET"); + + /** + * Weaviate container that uses Okta's dummy OIDC provider. + * Supports ClientCredentials flow. + */ + private static final Weaviate oktaContainer = Weaviate.custom() + .withOIDC(OKTA_CLIENT_ID, "https://dev-32300990.okta.com/oauth2/aus7e9kxbwYQB0eht5d7", "cid", "groups") + .build(); + + /** + * Exchange a Resource Owner Password grant for a bearer token + * and authenticate with it. + */ + @Test + public void test_bearerToken() throws Exception { + Assume.assumeTrue("WCS_DUMMY_CI_PW is not set", WCS_DUMMY_CI_PW != null && !WCS_DUMMY_CI_PW.isBlank()); + Assume.assumeTrue("no internet connection", hasInternetConnection()); + + var passwordAuth = Authentication.resourceOwnerPassword(WCS_DUMMY_CI_USERNAME, WCS_DUMMY_CI_PW, List.of()); + var t = SpyTokenProvider.stealToken(passwordAuth); + Assertions.assertThat(t.isValid()).as("bearer token is valid").isTrue(); + + // Expire this token immediately to force the client to fetch a new one. + var auth = SpyTokenProvider.spyOn(Authentication.bearerToken(t.accessToken(), t.refreshToken(), 0)); + pingWeaviate(wcsContainer, auth); + + var newT = auth.getToken(); + Assertions.assertThat(newT.accessToken()) + .as("expect access_token was refreshed") + .isNotEqualTo(t.accessToken()); + + // Check that the new token authenticates requests. + pingWeaviate(wcsContainer, auth); + pingWeaviateAsync(wcsContainer, auth); + } + + @Test + public void test_resourceOwnerPassword() throws Exception { + Assume.assumeTrue("WCS_DUMMY_CI_PW is not set", WCS_DUMMY_CI_PW != null && !WCS_DUMMY_CI_PW.isBlank()); + Assume.assumeTrue("no internet connection", hasInternetConnection()); + + // Check norwal resource owner password flow works. + var password = Authentication.resourceOwnerPassword(WCS_DUMMY_CI_USERNAME, WCS_DUMMY_CI_PW, List.of()); + var auth = SpyTokenProvider.spyOn(password); + pingWeaviate(wcsContainer, auth); + pingWeaviateAsync(wcsContainer, auth); + + // Get the token obtained by the wrapped TokenProvider. + var t = auth.getToken(); + + // Wait for the token to expire. Because we're testing against a live IdP + // and cannot control it at test, all other "mocking" options are more + // intrusive. Verify the new token is different from the one before. + waitForExpiry(t); + pingWeaviate(wcsContainer, auth); + + var newT = auth.getToken(); + Assertions.assertThat(newT.accessToken()) + .as("expect access_token was refreshed") + .isNotEqualTo(t.accessToken()); + } + + @Test + public void test_clientCredentials() throws Exception { + Assume.assumeTrue("OKTA_CLIENT_SECRET is not set", OKTA_CLIENT_SECRET != null && OKTA_CLIENT_SECRET.isBlank()); + Assume.assumeTrue("no internet connection", hasInternetConnection()); + + // Check norwal client credentials flow works. + var cc = Authentication.clientCredentials(OKTA_CLIENT_SECRET, List.of()); + var auth = SpyTokenProvider.spyOn(cc); + pingWeaviate(oktaContainer, auth); + pingWeaviateAsync(oktaContainer, auth); + + // Get the token obtained by the wrapped TokenProvider. + var t = auth.getToken(); + + // Wait for the token to expire. Because we're testing against a live IdP + // and cannot control it at test, all other "mocking" options are more + // intrusive. Verify the new token is different from the one before. + waitForExpiry(t); + pingWeaviate(oktaContainer, auth); + + var newT = auth.getToken(); + Assertions.assertThat(newT.accessToken()) + .as("expect access_token was refreshed") + .isNotEqualTo(t.accessToken()); + } + + /** Send an HTTP and gRPC requests using a "sync" client. */ + private static void pingWeaviate(final Weaviate container, Authentication auth) throws Exception { + try (final var client = container.getClient(conn -> conn.authentication(auth))) { + // Make an authenticated HTTP call + Assertions.assertThat(client.isLive()).isTrue(); + + // Make an authenticated gRPC call + var nsThings = unique("Things"); + client.collections.create(nsThings); + var things = client.collections.use(nsThings); + var randomUuid = UUID.randomUUID().toString(); + Assertions.assertThat(things.data.exists(randomUuid)).isFalse(); + } + } + + /** Send an HTTP and gRPC requests using an "async" client. */ + private static void pingWeaviateAsync(final Weaviate container, Authentication auth) throws Exception { + try (final var client = container.getClient(conn -> conn.authentication(auth))) { + try (final var async = client.async()) { + // Make an authenticated HTTP call + Assertions.assertThat(async.isLive().join()).isTrue(); + + // Make an authenticated gRPC call + var nsThings = unique("Things"); + async.collections.create(nsThings).join(); + var things = async.collections.use(nsThings); + var randomUuid = UUID.randomUUID().toString(); + Assertions.assertThat(things.data.exists(randomUuid).join()).isFalse(); + } + } + } + + private static boolean hasInternetConnection() { + return ping("www.google.com"); + } + + private static boolean ping(String site) { + InetSocketAddress addr = new InetSocketAddress(site, 80); + try (final var sock = new Socket()) { + sock.connect(addr, 3000); + return true; + } catch (IOException e) { + return false; + } + } + + private static void waitForExpiry(Token t) { + if (!t.isValid()) { + return; + } + if (t.neverExpires()) { + throw new IllegalStateException("token never expires"); + } + try { + Thread.sleep(Duration.ofSeconds(t.expiresIn()).toMillis()); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + } + + /** + * SpyTokenProvider is an Authentication implementation that spies on the + * TokenProvider it creates and can expose tokens generated by it. + */ + private static class SpyTokenProvider implements Authentication, TokenProvider { + + /** Spy on the TokenProvider returned by thie Authentication. */ + static SpyTokenProvider spyOn(Authentication auth) { + return new SpyTokenProvider(auth); + } + + /** Spy a token obtained by another TokenProvider. */ + static Token stealToken(Authentication auth) throws Exception { + var spy = spyOn(auth); + pingWeaviate(wcsContainer, spy); + return spy.getToken(); + } + + private Authentication authentication; + private TokenProvider tokenProvider; + + private SpyTokenProvider(Authentication actual) { + this.authentication = actual; + } + + @Override + public TokenProvider getTokenProvider(RestTransport transport) { + tokenProvider = authentication.getTokenProvider(transport); + return this; + } + + @Override + public Token getToken() { + return tokenProvider.getToken(); + } + } +} diff --git a/src/it/java/io/weaviate/integration/ORMITest.java b/src/it/java/io/weaviate/integration/ORMITest.java new file mode 100644 index 000000000..6095d91b4 --- /dev/null +++ b/src/it/java/io/weaviate/integration/ORMITest.java @@ -0,0 +1,372 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.time.OffsetDateTime; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration; +import org.junit.BeforeClass; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.annotations.Collection; +import io.weaviate.client6.v1.api.collections.annotations.Property; +import io.weaviate.client6.v1.api.collections.data.InsertManyResponse.InsertObject; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.containers.Container; + +public class ORMITest extends ConcurrentTest { + private static final WeaviateClient client = Container.WEAVIATE.getClient(); + + @Collection("ORMITestThings") + static record Thing( + // text / text[] + String text, + String[] textArray, + List textList, + + // date / date[] + OffsetDateTime date, + OffsetDateTime[] dateArray, + List dateList, + + // uuid / uuid[] + UUID uuid, + UUID[] uuidArray, + List uuidList, + + // int / int[] + @Property("short") short short_, + Short shortBoxed, + short[] shortArray, + Short[] shortBoxedArray, + List shortBoxedList, + + @Property("int") int int_, + Integer intBoxed, + int[] intArray, + Integer[] intBoxedArray, + List intBoxedList, + + @Property("long") long long_, + Long longBoxed, + long[] longArray, + Long[] longBoxedArray, + List longBoxedList, + + // number / number[] + @Property("float") float float_, + Float floatBoxed, + float[] floatArray, + Float[] floatBoxedArray, + List floatBoxedList, + + @Property("double") double double_, + Double doubleBoxed, + double[] doubleArray, + Double[] doubleBoxedArray, + List doubleBoxedList, + + // boolean / boolean[] + @Property("boolean") boolean boolean_, + Boolean booleanBoxed, + boolean[] booleanArray, + Boolean[] booleanBoxedArray, + List booleanBoxedList, + + PhoneNumber phoneNumber, + GeoCoordinates geoCoordinates) { + } + + @BeforeClass + public static void setUp() throws Exception { + client.collections.create(Thing.class); + } + + @Test + public void test_createCollection() throws Exception { + // Arrange + var things = client.collections.use(Thing.class); + + // Act + var config = things.config.get(); + + // Assert + Assertions.assertThat(config).get() + .returns("ORMITestThings", CollectionConfig::collectionName) + .extracting(CollectionConfig::properties, + InstanceOfAssertFactories.list(io.weaviate.client6.v1.api.collections.Property.class)) + .extracting(p -> Map.entry( + p.propertyName(), + p.dataTypes().get(0))) + .contains( + Map.entry("text", "text"), + Map.entry("textArray", "text[]"), + Map.entry("textList", "text[]"), + + Map.entry("date", "date"), + Map.entry("dateArray", "date[]"), + Map.entry("dateList", "date[]"), + + Map.entry("uuid", "uuid"), + Map.entry("uuidArray", "uuid[]"), + Map.entry("uuidList", "uuid[]"), + + Map.entry("short", "int"), + Map.entry("shortBoxed", "int"), + Map.entry("shortArray", "int[]"), + Map.entry("shortBoxedArray", "int[]"), + Map.entry("shortBoxedList", "int[]"), + + Map.entry("int", "int"), + Map.entry("intBoxed", "int"), + Map.entry("intArray", "int[]"), + Map.entry("intBoxedArray", "int[]"), + Map.entry("intBoxedList", "int[]"), + + Map.entry("long", "int"), + Map.entry("longBoxed", "int"), + Map.entry("longArray", "int[]"), + Map.entry("longBoxedArray", "int[]"), + Map.entry("longBoxedList", "int[]"), + + Map.entry("float", "number"), + Map.entry("floatBoxed", "number"), + Map.entry("floatArray", "number[]"), + Map.entry("floatBoxedArray", "number[]"), + Map.entry("floatBoxedList", "number[]"), + + Map.entry("double", "number"), + Map.entry("doubleBoxed", "number"), + Map.entry("doubleArray", "number[]"), + Map.entry("doubleBoxedArray", "number[]"), + Map.entry("doubleBoxedList", "number[]"), + + Map.entry("boolean", "boolean"), + Map.entry("booleanBoxed", "boolean"), + Map.entry("booleanArray", "boolean[]"), + Map.entry("booleanBoxedArray", "boolean[]"), + Map.entry("booleanBoxedList", "boolean[]"), + + Map.entry("phoneNumber", "phoneNumber"), + Map.entry("geoCoordinates", "geoCoordinates")); + } + + private static final RecursiveComparisonConfiguration COMPARISON_CONFIG = RecursiveComparisonConfiguration.builder() + // Assertj is having a really bad time comparing List, + // so we'll just always return true here. + .withComparatorForFields((a, b) -> 0, "floatBoxedList") + .withComparatorForType((a, b) -> Double.compare(a.doubleValue(), b.doubleValue()), Number.class) + .withComparatorForType(ORMITest::comparePhoneNumbers, PhoneNumber.class) + .build(); + + @Test + public void test_insertAndQuery() throws Exception { + short short_ = 666; + int int_ = 666; + long long_ = 666; + float float_ = 666; + double double_ = 666; + boolean boolean_ = true; + UUID uuid = UUID.randomUUID(); + OffsetDateTime date = OffsetDateTime.now(); + String text = "hello"; + + var thing = new Thing( + text, + new String[] { text }, + List.of(text), + + OffsetDateTime.now(), + new OffsetDateTime[] { date }, + List.of(date), + + UUID.randomUUID(), + new UUID[] { uuid }, + List.of(uuid), + + short_, + short_, + new short[] { short_ }, + new Short[] { short_ }, + List.of(short_), + + int_, + int_, + new int[] { int_ }, + new Integer[] { int_ }, + List.of(int_), + + long_, + long_, + new long[] { long_ }, + new Long[] { long_ }, + List.of(long_), + + float_, + float_, + new float[] { float_ }, + new Float[] { float_ }, + List.of(float_), + + double_, + double_, + new double[] { double_ }, + new Double[] { double_ }, + List.of(double_), + + boolean_, + boolean_, + new boolean[] { boolean_ }, + new Boolean[] { boolean_ }, + List.of(boolean_), + + PhoneNumber.international("+380 95 1433336"), + new GeoCoordinates(1f, 2f)); + + var things = client.collections.use(Thing.class); + + // Act + var inserted = things.data.insert(thing); + + // Assert + var response = things.query.fetchObjectById(inserted.uuid()); + var got = Assertions.assertThat(response).get().actual(); + + Assertions.assertThat(got.properties()) + .usingRecursiveComparison(COMPARISON_CONFIG) + .isEqualTo(thing); + } + + @Test + public void test_insertManyAndQuery() throws Exception { + short short_ = 666; + int int_ = 666; + long long_ = 666; + float float_ = 666; + double double_ = 666; + boolean boolean_ = true; + UUID uuid = UUID.randomUUID(); + OffsetDateTime date = OffsetDateTime.now(); + String text = "hello"; + + var thing = new Thing( + text, + new String[] { text }, + List.of(text), + + OffsetDateTime.now(), + new OffsetDateTime[] { date }, + List.of(date), + + UUID.randomUUID(), + new UUID[] { uuid }, + List.of(uuid), + + short_, + short_, + new short[] { short_ }, + new Short[] { short_ }, + List.of(short_), + + int_, + int_, + new int[] { int_ }, + new Integer[] { int_ }, + List.of(int_), + + long_, + long_, + new long[] { long_ }, + new Long[] { long_ }, + List.of(long_), + + float_, + float_, + new float[] { float_ }, + new Float[] { float_ }, + List.of(float_), + + double_, + double_, + new double[] { double_ }, + new Double[] { double_ }, + List.of(double_), + + boolean_, + boolean_, + new boolean[] { boolean_ }, + new Boolean[] { boolean_ }, + List.of(boolean_), + + PhoneNumber.international("+380 95 1433336"), + new GeoCoordinates(1f, 2f)); + + var things = client.collections.use(Thing.class); + + // Act + var inserted = things.data.insertMany(thing, thing, thing); + + // Assert + var uuids = inserted.responses().stream().map(InsertObject::uuid).toArray(String[]::new); + var got = things.query.fetchObjects(q -> q.filters(Filter.uuid().containsAny(uuids))); + Assertions.assertThat(got.objects()) + .hasSize(3) + .usingRecursiveComparison(COMPARISON_CONFIG) + .asInstanceOf(InstanceOfAssertFactories.list(Thing.class)); + } + + @Collection("ORMITestSongs") + record Song( + String title, + String album, + int year, + boolean hasAward, + Long monthlyListeners) { + } + + /** + * Test that serialization works correctly when some fields are null and + * deserialization works correctly when some properties are not returned. + */ + @Test + public void test_partialScan() throws IOException { + client.collections.create(Song.class); + + var songs = client.collections.use(Song.class); + + // Act: insert with nulls + var dystopia = songs.data.insert(new Song( + "Dystopia", + null, + 2016, + true, + null)); + + // Act: return subset of the properties + var got = songs.query.fetchObjectById(dystopia.uuid(), + q -> q.returnProperties("title", "hasAward")); + + // Assert + Assertions.assertThat(got).get() + .extracting(WeaviateObject::properties) + .returns("Dystopia", Song::title) + .returns(null, Song::album) + .returns(0, Song::year) + .returns(true, Song::hasAward) + .returns(null, Song::monthlyListeners); + } + + static int comparePhoneNumbers(PhoneNumber phone1, PhoneNumber phone2) { + return phone1.rawInput().compareTo(phone2.rawInput()); + } +} diff --git a/src/it/java/io/weaviate/integration/PaginationITest.java b/src/it/java/io/weaviate/integration/PaginationITest.java new file mode 100644 index 000000000..be79cd1b2 --- /dev/null +++ b/src/it/java/io/weaviate/integration/PaginationITest.java @@ -0,0 +1,196 @@ +package io.weaviate.integration; + +import static org.junit.Assume.assumeTrue; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.atomic.AtomicInteger; + +import org.assertj.core.api.Assertions; +import org.junit.Assume; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.WeaviateException; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.pagination.PaginationException; +import io.weaviate.client6.v1.api.collections.query.Metadata; +import io.weaviate.containers.Container; + +public class PaginationITest extends ConcurrentTest { + private static final WeaviateClient client = Container.WEAVIATE.getClient(); + + @Test + public void testIterateAll() throws IOException { + // Arrange + var nsThings = ns("Things"); + var count = 150; + + client.collections.create(nsThings); + var things = client.collections.use(nsThings); + + var inserted = new ArrayList(); + for (var i = 0; i < count; i++) { + var object = things.data.insert(Collections.emptyMap()); + inserted.add(object.uuid()); + } + assumeTrue("all objects were inserted", inserted.size() == count); + + var allThings = things.paginate(); + + // Act: stream + var gotStream = allThings.stream().map(WeaviateObject::uuid).toList(); + + // Assert + Assertions.assertThat(gotStream) + .as("stream fetched all objects") + .hasSize(inserted.size()) + .containsAll(inserted); + + // Act: for-loop + var gotLoop = new ArrayList(); + for (var thing : allThings) { + gotLoop.add(thing.uuid()); + } + + // Assert + Assertions.assertThat(gotLoop) + .as("list fetched all objects") + .hasSize(inserted.size()) + .containsAll(inserted); + + Assertions.assertThat(gotStream) + .as("stream and list return consistent order") + .containsExactlyElementsOf(gotLoop); + } + + @Test + public void testResumePagination() throws IOException { + // Arrange + var nsThings = ns("Things"); + var count = 10; + + client.collections.create(nsThings); + + var things = client.collections.use(nsThings); + var inserted = new ArrayList(); + for (var i = 0; i < count; i++) { + var object = things.data.insert(Collections.emptyMap()); + inserted.add(object.uuid()); + } + + // Iterate over first 5 objects + String lastId = things.paginate(p -> p.pageSize(5)).stream() + .limit(5).map(thing -> thing.uuid()) + .reduce((prev, next) -> next).get(); + + // Act + var remaining = things.paginate(p -> p.fromCursor(lastId)).stream().count(); + + // Assert + Assertions.assertThat(remaining).isEqualTo(5); + } + + @Test + public void testWithQueryOptions() throws IOException { + // Arrange + var nsThings = ns("Things"); + var count = 10; + + client.collections.create(nsThings, + c -> c.properties( + Property.text("fetch_me"), + Property.integer("dont_fetch"))); + + var things = client.collections.use(nsThings); + var inserted = new ArrayList(); + for (var i = 0; i < count; i++) { + var object = things.data.insert(Collections.emptyMap()); + inserted.add(object.uuid()); + } + + // Act / Assert + var withSomeProperties = things.paginate(p -> p + .returnMetadata(Metadata.CREATION_TIME_UNIX) + .returnProperties("fetch_me")); + for (var thing : withSomeProperties) { + Assertions.assertThat(thing.properties()) + .as("uuid=" + thing.uuid()) + .doesNotContainKey("dont_fetch"); + + Assertions.assertThat(thing.createdAt()).isNotNull(); + } + } + + @Test + public void testAsyncPaginator() throws Exception, InterruptedException, ExecutionException { + // Arrange + var nsThings = ns("Things"); + var count = 10; + + client.collections.create(nsThings); + + try (final var async = client.async()) { + var things = async.collections.use(nsThings); + + var futures = new CompletableFuture[count]; + var inserted = new ArrayList(); + for (var i = 0; i < count; i++) { + futures[i] = things.data.insert(Collections.emptyMap()) + .thenAccept(object -> inserted.add(object.uuid())); + } + CompletableFuture.allOf(futures).get(); + + // Act + var objectCount = new AtomicInteger(); + var countAll = things.paginate(p -> p.pageSize(5).prefetch(true)) + .forEach(__ -> objectCount.getAndIncrement()); + + // Assert + if (!countAll.isDone()) { + Assume.assumeTrue("iteration not completed", objectCount.get() < count); + } + + countAll.get(); // Wait for it to complete. + Assertions.assertThat(objectCount.get()) + .as("object count after iteration completed") + .isEqualTo(count); + } + } + + @Test(expected = PaginationException.class) + public void testFailedPagination() throws IOException { + var things = client.collections.use("Unknown"); + things.paginate().forEach(System.out::println); + } + + @Test(expected = PaginationException.class) + public void testFailedAsyncPagination_forEach() throws Throwable { + try (final var async = client.async()) { + var things = async.collections.use("Unknown"); + try { + things.paginate().forEach(__ -> System.out.println("called once")).join(); + } catch (CompletionException e) { + throw e.getCause(); // CompletableFuture exceptions are always wrapped + } + } + } + + @Test(expected = WeaviateException.class) + public void testFailedAsyncPagination_forPage() throws Throwable { + try (final var async = client.async()) { + var things = async.collections.use("Unknown"); + try { + things.paginate().forPage(__ -> System.out.println("called once")).join(); + } catch (CompletionException e) { + throw e.getCause(); // CompletableFuture exceptions are always wrapped + } + } + } +} diff --git a/src/it/java/io/weaviate/integration/RbacITest.java b/src/it/java/io/weaviate/integration/RbacITest.java new file mode 100644 index 000000000..57d6ca7e7 --- /dev/null +++ b/src/it/java/io/weaviate/integration/RbacITest.java @@ -0,0 +1,307 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.Authentication; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.rbac.AliasesPermission; +import io.weaviate.client6.v1.api.rbac.BackupsPermission; +import io.weaviate.client6.v1.api.rbac.ClusterPermission; +import io.weaviate.client6.v1.api.rbac.CollectionsPermission; +import io.weaviate.client6.v1.api.rbac.DataPermission; +import io.weaviate.client6.v1.api.rbac.GroupsPermission; +import io.weaviate.client6.v1.api.rbac.NodesPermission; +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.api.rbac.ReplicatePermission; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.api.rbac.RolesPermission; +import io.weaviate.client6.v1.api.rbac.RolesPermission.Scope; +import io.weaviate.client6.v1.api.rbac.TenantsPermission; +import io.weaviate.client6.v1.api.rbac.UsersPermission; +import io.weaviate.client6.v1.api.rbac.groups.GroupType; +import io.weaviate.client6.v1.api.rbac.roles.UserAssignment; +import io.weaviate.client6.v1.api.rbac.users.DbUser; +import io.weaviate.client6.v1.api.rbac.users.User; +import io.weaviate.client6.v1.api.rbac.users.UserType; +import io.weaviate.containers.Weaviate; + +public class RbacITest extends ConcurrentTest { + private static final String ADMIN_USER = "admin-alex"; + private static final String API_KEY = "admin-alex-secret"; + + /** Name of the root role, which exists by default. */ + private static final String ROOT_ROLE = "root"; + + /** Name of the admin role, which exists by default. */ + private static final String ADMIN_ROLE = "admin"; + + /** Name of the viewer role, which exists by default. */ + private static final String VIEWER_ROLE = "viewer"; + + private static final Weaviate container = Weaviate.custom() + .withAdminUsers(ADMIN_USER) + .withApiKeys(API_KEY) + .withRbac() + .withOIDC() // Enable OIDC to have Weaviate return different user types (db, db_env, oidc) + .build(); + + private static final WeaviateClient client = container + .getClient(fn -> fn.authentication(Authentication.apiKey(API_KEY))); + + @Test + public void test_roles_Lifecycle() throws IOException { + // Arrange + var myCollection = "Things"; + var nsRole = ns("VectorOwner"); + + List permissions = new ArrayList<>() { + { + add(Permission.backups(myCollection, BackupsPermission.Action.MANAGE)); + add(Permission.cluster(ClusterPermission.Action.READ)); + add(Permission.nodes(myCollection, NodesPermission.Action.READ)); + add(Permission.roles(VIEWER_ROLE, Scope.MATCH, RolesPermission.Action.CREATE)); + add(Permission.collections(myCollection, CollectionsPermission.Action.CREATE)); + add(Permission.data(myCollection, DataPermission.Action.UPDATE)); + add(Permission.tenants(myCollection, "my-tenant", TenantsPermission.Action.DELETE)); + add(Permission.users("my-user", UsersPermission.Action.READ)); + add(Permission.replicate(myCollection, "my-shard", ReplicatePermission.Action.READ)); + } + }; + + requireAtLeast(Weaviate.Version.V132, () -> { + permissions.add( + Permission.aliases("ThingsAlias", myCollection, AliasesPermission.Action.CREATE)); + }); + requireAtLeast(Weaviate.Version.V133, () -> { + permissions.add( + Permission.groups("my-group", GroupType.OIDC, GroupsPermission.Action.READ)); + }); + + requireAtLeast(Weaviate.Version.V132, () -> { + permissions.add( + Permission.aliases("ThingsAlias", myCollection, AliasesPermission.Action.CREATE)); + }); + requireAtLeast(Weaviate.Version.V133, () -> { + permissions.add( + Permission.groups("my-group", GroupType.OIDC, GroupsPermission.Action.READ)); + }); + + // Act: create role + client.roles.create(nsRole, permissions); + + var role = client.roles.get(nsRole); + Assertions.assertThat(role).get() + .as("created role") + .returns(nsRole, Role::name) + .extracting(Role::permissions, InstanceOfAssertFactories.list(Permission.class)) + .containsAll(permissions); + + // Act:: add extra permissions + var extra = new Permission[] { + Permission.data("Songs", DataPermission.Action.DELETE), + Permission.users("john-doe", UsersPermission.Action.ASSIGN_AND_REVOKE), + }; + client.roles.addPermissions(nsRole, extra); + + Assertions.assertThat(client.roles.hasPermission(nsRole, extra[0])) + .as("has extra data permission") + .isTrue(); + + Assertions.assertThat(client.roles.hasPermission(nsRole, extra[1])) + .as("has extra users permission") + .isTrue(); + + // Act: remove extra permissions + client.roles.removePermissions(nsRole, extra); + + Assertions.assertThat(client.roles.hasPermission(nsRole, extra[0])) + .as("extra data permission removed") + .isFalse(); + + Assertions.assertThat(client.roles.hasPermission(nsRole, extra[1])) + .as("extra users permission removed") + .isFalse(); + + // Act: delete role + client.roles.delete(nsRole); + Assertions.assertThat(client.roles.exists(nsRole)) + .as("role is deleted") + .isFalse(); + } + + @Test + public void test_roles_list() throws IOException { + Assertions.assertThat(client.roles.list()) + .extracting(Role::name) + .contains(ROOT_ROLE, ADMIN_ROLE, VIEWER_ROLE); + } + + @Test + public void test_roles_assignedUsers() throws IOException { + Assertions.assertThat(client.roles.assignedUserIds(ROOT_ROLE)) + .hasSize(1) + .containsOnly(ADMIN_USER); + } + + @Test + public void test_roles_userAssignments() throws IOException { + var assignments = client.roles.userAssignments(ROOT_ROLE); + Assertions.assertThat(assignments) + .hasSize(2) + .extracting(UserAssignment::userId) + .containsOnly(ADMIN_USER); + + Assertions.assertThat(assignments) + .extracting(UserAssignment::userType) + .containsOnly(UserType.DB_ENV_USER, UserType.OIDC); + } + + @Test + public void test_groups() throws IOException { + Weaviate.Version.V133.orSkip(); + + var mediaGroup = "./media-group"; + var friendGroup = "./friend-group"; + + client.groups.assignRoles(mediaGroup, VIEWER_ROLE); + client.groups.assignRoles(friendGroup, ADMIN_ROLE, VIEWER_ROLE); + + Assertions.assertThat(client.groups.assignedRoles(friendGroup)) + .as("assigned to " + friendGroup) + .extracting(Role::name) + .containsOnly(ADMIN_ROLE, VIEWER_ROLE); + + Assertions.assertThat(client.groups.knownGroupNames()) + .as("known group names") + .contains(mediaGroup, friendGroup); + + client.groups.revokeRoles(mediaGroup, VIEWER_ROLE); + Assertions.assertThat(client.groups.knownGroupNames()) + .as("know group names (no root)") + .doesNotContain(mediaGroup); + } + + @Test + public void test_users_myUser() throws IOException { + var adminRoles = Assertions.assertThat(client.users.myUser()) + .returns(ADMIN_USER, User::id) + .extracting(User::roles, InstanceOfAssertFactories.list(Role.class)) + .extracting(Role::name) + .actual(); + + Assertions.assertThat(client.users.db.assignedRoles(ADMIN_USER)) + .extracting(Role::name) + .containsAll(adminRoles); + } + + @Test + public void test_users_db() throws IOException { + var userId = ns("user"); + var roleName = ns("rock-n-role"); + + var apiKey = client.users.db.create(userId); + assertValidApiKey(apiKey); + + client.roles.create(roleName); + + client.users.db.assignRoles(userId, roleName); + Assertions.assertThat(client.users.db.assignedRoles(userId)) + .as("role assigned") + .extracting(Role::name) + .contains(roleName); + + client.users.db.revokeRoles(userId, roleName); + Assertions.assertThat(client.users.db.assignedRoles(userId)) + .as("role revoked") + .extracting(Role::name) + .doesNotContain(roleName); + + var deactivated = client.users.db.deactivate(userId); + Assertions.assertThat(deactivated) + .as("user was deactivated") + .isTrue(); + Assertions.assertThat(client.users.db.byName(userId)).get() + .as("user is deactivated") + .returns(false, DbUser::active); + + deactivated = client.users.db.deactivate(userId); + Assertions.assertThat(deactivated) + .as("user was already deactivated") + .isFalse(); + + var activated = client.users.db.activate(userId); + Assertions.assertThat(activated) + .as("user was activated") + .isTrue(); + Assertions.assertThat(client.users.db.byName(userId)).get() + .as("user is activated") + .returns(true, DbUser::active); + + activated = client.users.db.activate(userId); + Assertions.assertThat(activated) + .as("user was already active") + .isFalse(); + + apiKey = client.users.db.rotateKey(userId); + assertValidApiKey(apiKey); + + var all = client.users.db.list(users -> users.includeLastUsedAt(true)); + Assertions.assertThat(all) + .as("list users include lastUsedTime ") + .allMatch(user -> user.lastUsedAt() != null) + .extracting(DbUser::id) + .contains(userId, ADMIN_USER); + + var deleted = client.users.db.delete(userId); + Assertions.assertThat(deleted) + .as("user was deleted") + .isTrue(); + Assertions.assertThat(client.users.db.byName(userId)) + .as("user is deleted") + .isEmpty(); + + deleted = client.users.db.delete(userId); + Assertions.assertThat(deleted) + .as("user was already deleted") + .isFalse(); + } + + @Test + public void test_users_oidc() throws IOException { + var userId = ns("user"); + var roleName = ns("rock-n-role"); + + client.roles.create(roleName); + + client.users.oidc.assignRoles(userId, roleName); + Assertions.assertThat(client.users.oidc.assignedRoles(userId)) + .as("role assigned") + .extracting(Role::name) + .contains(roleName); + + client.users.oidc.revokeRoles(userId, roleName); + Assertions.assertThat(client.users.oidc.assignedRoles(userId)) + .as("role revoked") + .extracting(Role::name) + .doesNotContain(roleName); + } + + /** + * Create a new client with API-key authentication + * and check that it can make authenticated requests. + */ + private void assertValidApiKey(String apiKey) { + try (final var c = container.getClient(cfg -> cfg.authentication(Authentication.apiKey(apiKey)))) { + Assertions.assertThatCode(() -> c.isLive()).as("check API key is valid").doesNotThrowAnyException(); + } catch (Exception e) { + throw new AssertionError(e); + } + } +} diff --git a/src/it/java/io/weaviate/integration/ReferencesITest.java b/src/it/java/io/weaviate/integration/ReferencesITest.java new file mode 100644 index 000000000..e5310ac28 --- /dev/null +++ b/src/it/java/io/weaviate/integration/ReferencesITest.java @@ -0,0 +1,186 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.query.QueryReference; +import io.weaviate.containers.Container; + +/** + * Scenarios related to reference properties: + *
    + *
  • create collection with (nested) reference properties
  • + *
  • insert objects with (nested) references
  • + *
  • add (nested) references
  • + *
  • search by reference (nested) properties
  • + *
+ */ +public class ReferencesITest extends ConcurrentTest { + private static final WeaviateClient client = Container.WEAVIATE.getClient(); + + @Test + public void testReferences() throws IOException { + // Arrange: create collection with cross-references + var nsArtists = ns("Artists"); + var nsGrammy = ns("Grammy"); + var nsOscar = ns("Oscar"); + + client.collections.create(nsOscar); + client.collections.create(nsGrammy); + + // Act: create Artists collection with hasAwards reference + client.collections.create(nsArtists, + col -> col + .properties( + Property.text("name"), + Property.integer("age")) + .references( + ReferenceProperty.to("hasAwards", nsGrammy, nsOscar))); + + var artists = client.collections.use(nsArtists); + var grammies = client.collections.use(nsGrammy); + var oscars = client.collections.use(nsOscar); + + // Act: check collection configuration is correct + var collectionArtists = artists.config.get(); + Assertions.assertThat(collectionArtists).get() + .as("Artists: create collection") + .extracting(c -> c.references().stream().findFirst()) + .as("has one reference property").extracting(Optional::get) + .returns("hasAwards", ReferenceProperty::propertyName) + .extracting(ReferenceProperty::dataTypes, InstanceOfAssertFactories.list(String.class)) + .containsOnly(nsGrammy, nsOscar); + + // Act: insert some data + var grammy_1 = grammies.data.insert(Map.of()); + var grammy_2 = grammies.data.insert(Map.of()); + var oscar_1 = oscars.data.insert(Map.of()); + var oscar_2 = oscars.data.insert(Map.of()); + + var alex = artists.data.insert( + Map.of("name", "Alex"), + opt -> opt + .reference("hasAwards", ObjectReference.uuids( + grammy_1.uuid(), oscar_1.uuid())) + .reference("hasAwards", ObjectReference.objects(grammy_2, oscar_2))); + + // Act: add one more reference + var nsMovies = ns("Movies"); + client.collections.create(nsMovies); + artists.config.addReference("featuredIn", nsMovies); + + collectionArtists = artists.config.get(); + Assertions.assertThat(collectionArtists).get() + .as("Artists: add reference to Movies") + .extracting(c -> c.references().stream() + .filter(property -> property.propertyName().equals("featuredIn")).findFirst()) + .as("featuredIn reference property").extracting(Optional::get) + .extracting(ReferenceProperty::dataTypes, InstanceOfAssertFactories.list(String.class)) + .containsOnly(nsMovies); + + var gotAlex = artists.query.fetchObjectById(alex.uuid(), + opt -> opt.returnReferences( + QueryReference.multi("hasAwards", nsOscar), + QueryReference.multi("hasAwards", nsGrammy))); + + Assertions.assertThat(gotAlex).get() + .as("Artists: fetch by id including hasAwards references") + + // Cast references to Map> + .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class)) + .as("hasAwards object reference").extractingByKey("hasAwards") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + + .extracting(object -> object.uuid()) + .containsOnly( + // INVESTIGATE: When references to 2+ collections are requested, + // seems to Weaviate only return references to the first one in the list. + // In this case we request { "hasAwards": Oscars } and { "hasAwards": Grammys } + // so the latter will not be in the response. + // + // grammy_1.metadata().id(), grammy_2.metadata().id(), + oscar_1.uuid(), oscar_2.uuid()); + } + + @Test + public void testNestedReferences() throws IOException { + // Arrange: create collection with cross-references + var nsArtists = ns("Artists"); + var nsGrammy = ns("Grammy"); + var nsAcademy = ns("Academy"); + + client.collections.create(nsAcademy, + opt -> opt + .properties(Property.text("ceo"))); + + // Act: create Artists collection with hasAwards reference + client.collections.create(nsGrammy, + col -> col + .references(ReferenceProperty.to("presentedBy", nsAcademy))); + + client.collections.create(nsArtists, + col -> col + .properties( + Property.text("name"), + Property.integer("age")) + .references( + ReferenceProperty.to("hasAwards", nsGrammy))); + + var artists = client.collections.use(nsArtists); + var grammies = client.collections.use(nsGrammy); + var academies = client.collections.use(nsAcademy); + + // Act: insert some data + var musicAcademy = academies.data.insert(Map.of("ceo", "Harvy Mason")); + + var grammy_1 = grammies.data.insert(Map.of(), + opt -> opt.reference("presentedBy", ObjectReference.objects(musicAcademy))); + + var alex = artists.data.insert( + Map.of("name", "Alex"), + opt -> opt + .reference("hasAwards", ObjectReference.objects(grammy_1))); + + // Assert: fetch nested references + var gotAlex = artists.query.fetchObjectById(alex.uuid(), + opt -> opt.returnReferences( + QueryReference.single("hasAwards", + ref -> ref + // Name of the CEO of the presenting academy + .returnReferences( + QueryReference.single("presentedBy", r -> r.returnProperties("ceo")))))); + + Assertions.assertThat(gotAlex).get() + .as("Artists: fetch by id including nested references") + + // Cast references to Map> + .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class)) + .as("hasAwards object reference").extractingByKey("hasAwards") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + + .hasSize(1).allSatisfy(award -> Assertions.assertThat(award) + .returns(grammy_1.uuid(), grammy -> grammy.uuid()) + + // Cast references to Map> + .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class)) + .as("presentedBy object reference").extractingByKey("presentedBy") + .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class)) + + .hasSize(1).extracting(WeaviateObject::properties) + .allSatisfy(properties -> Assertions.assertThat(properties) + .asInstanceOf(InstanceOfAssertFactories.map(String.class, Object.class)) + .containsEntry("ceo", "Harvy Mason"))); + } +} diff --git a/src/it/java/io/weaviate/integration/SearchITest.java b/src/it/java/io/weaviate/integration/SearchITest.java new file mode 100644 index 000000000..35f0aa30d --- /dev/null +++ b/src/it/java/io/weaviate/integration/SearchITest.java @@ -0,0 +1,793 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.time.OffsetDateTime; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletionException; +import java.util.concurrent.ExecutionException; + +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.rules.TestRule; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.generate.GenerativeObject; +import io.weaviate.client6.v1.api.collections.generate.TaskOutput; +import io.weaviate.client6.v1.api.collections.generative.DummyGenerative; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.api.collections.query.GroupBy; +import io.weaviate.client6.v1.api.collections.query.Metadata; +import io.weaviate.client6.v1.api.collections.query.QueryResponseGroup; +import io.weaviate.client6.v1.api.collections.query.Rerank; +import io.weaviate.client6.v1.api.collections.query.SortBy; +import io.weaviate.client6.v1.api.collections.query.Target; +import io.weaviate.client6.v1.api.collections.rerankers.DummyReranker; +import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw; +import io.weaviate.client6.v1.api.collections.vectorindex.MultiVector; +import io.weaviate.containers.Container; +import io.weaviate.containers.Container.ContainerGroup; +import io.weaviate.containers.Img2VecNeural; +import io.weaviate.containers.Model2Vec; +import io.weaviate.containers.Weaviate; + +public class SearchITest extends ConcurrentTest { + private static final ContainerGroup compose = Container.compose( + Weaviate.custom() + .withModel2VecUrl(Model2Vec.URL) + .withImageInference(Img2VecNeural.URL, Img2VecNeural.MODULE) + .addModules(Generative.Kind.DUMMY.jsonValue(), Reranker.Kind.DUMMY.jsonValue()) + .build(), + Container.IMG2VEC_NEURAL, + Container.MODEL2VEC); + @ClassRule // Bind containers to the lifetime of the test + public static final TestRule _rule = compose.asTestRule(); + private static final WeaviateClient client = compose.getClient(); + + private static final String COLLECTION = unique("Things"); + private static final String VECTOR_INDEX = "bring_your_own"; + private static final List CATEGORIES = List.of("red", "green"); + + /** + * One of the inserted vectors which will be used as target vector for search. + */ + private static float[] searchVector; + + @BeforeClass + public static void beforeAll() throws IOException { + createTestCollection(); + var created = populateTest(10); + searchVector = created.values().iterator().next(); + } + + @Test + public void testNearVector() { + var things = client.collections.use(COLLECTION); + var result = things.query.nearVector(searchVector, + opt -> opt + .distance(2f) + .limit(3) + .returnMetadata(Metadata.DISTANCE)); + + Assertions.assertThat(result.objects()).hasSize(3); + float maxDistance = Collections.max(result.objects(), + Comparator.comparing(obj -> obj.queryMetadata().distance())).queryMetadata().distance(); + Assertions.assertThat(maxDistance).isLessThanOrEqualTo(2f); + } + + @Test + public void testNearVector_groupBy() { + var things = client.collections.use(COLLECTION); + var result = things.query.nearVector(searchVector, + opt -> opt.distance(10f), + GroupBy.property("category", 2, 5)); + + Assertions.assertThat(result.groups()) + .as("group per category").containsOnlyKeys(CATEGORIES) + .hasSizeLessThanOrEqualTo(2) + .allSatisfy((category, group) -> { + Assertions.assertThat(group) + .as("group name").returns(category, QueryResponseGroup::name); + Assertions.assertThat(group.numberOfObjects()) + .as("[%s] has 1+ object", category).isLessThanOrEqualTo(5L); + }); + + Assertions.assertThat(result.objects()) + .as("object belongs a group") + .allMatch(obj -> result.groups().get(obj.belongsToGroup()).objects().contains(obj)); + } + + /** + * Insert 10 objects with random vectors. + * + * @return IDs of inserted objects and their corresponding vectors. + */ + private static Map populateTest(int n) throws IOException { + var created = new HashMap(); + + var things = client.collections.use(COLLECTION); + for (int i = 0; i < n; i++) { + var vector = randomVector(10, -.01f, .001f); + var object = things.data.insert( + Map.of("category", CATEGORIES.get(i % CATEGORIES.size())), + metadata -> metadata + .uuid(randomUUID()) + .vectors(Vectors.of(VECTOR_INDEX, vector))); + + created.put(object.uuid(), vector); + } + + return created; + } + + /** + * Create {@link COLLECTION} with {@link VECTOR_INDEX} vector index. + * + * @throws IOException + */ + private static void createTestCollection() throws IOException { + client.collections.create(COLLECTION, cfg -> cfg + .properties(Property.text("category")) + .vectorConfig(VectorConfig.selfProvided(VECTOR_INDEX))); + } + + @Test + public void testNearText() throws IOException { + var nsSongs = ns("Songs"); + client.collections.create(nsSongs, + col -> col + .properties(Property.text("title")) + .vectorConfig(VectorConfig.text2vecModel2Vec())); + + var songs = client.collections.use(nsSongs); + var submarine = songs.data.insert(Map.of("title", "Yellow Submarine")); + songs.data.insert(Map.of("title", "Run Through The Jungle")); + songs.data.insert(Map.of("title", "Welcome To The Jungle")); + + var result = songs.query.nearText("forest", + opt -> opt + .distance(0.9f) + .moveTo(.98f, to -> to.concepts("tropical")) + .moveAway(.4f, away -> away.uuids(submarine.uuid())) + .returnProperties("title")); + + Assertions.assertThat(result.objects()).hasSize(2) + .extracting(WeaviateObject::properties).allSatisfy( + properties -> Assertions.assertThat(properties) + .allSatisfy((_k, v) -> Assertions.assertThat((String) v).contains("Jungle"))); + } + + @Test + public void testNearText_groupBy() throws IOException { + var vectorizer = VectorConfig.text2vecModel2Vec(); + + var nsArtists = ns("Artists"); + client.collections.create(nsArtists, + col -> col + .properties(Property.text("name")) + .vectorConfig(vectorizer)); + + var artists = client.collections.use(nsArtists); + var beatles = artists.data.insert(Map.of("name", "Beatles")); + var ccr = artists.data.insert(Map.of("name", "CCR")); + + var nsSongs = ns("Songs"); + client.collections.create(nsSongs, + col -> col + .properties(Property.text("title")) + .references(ReferenceProperty.to("performedBy", nsArtists)) + .vectorConfig(vectorizer)); + + var songs = client.collections.use(nsSongs); + songs.data.insert(Map.of("title", "Yellow Submarine"), + s -> s.reference("performedBy", ObjectReference.objects(beatles))); + songs.data.insert(Map.of("title", "Run Through The Jungle"), + s -> s.reference("performedBy", ObjectReference.objects(ccr))); + + var result = songs.query.nearText("nature", + opt -> opt.returnProperties("title"), + GroupBy.property("performedBy", 2, 1)); + + Assertions.assertThat(result.groups()).hasSize(2) + .containsOnlyKeys( + "weaviate://localhost/%s/%s".formatted(nsArtists, beatles.uuid()), + "weaviate://localhost/%s/%s".formatted(nsArtists, ccr.uuid())); + } + + @Test + public void testNearImage() throws IOException { + var nsCats = ns("Cats"); + + client.collections.create(nsCats, + collection -> collection + .properties( + Property.text("breed"), + Property.blob("img")) + .vectorConfig(VectorConfig.img2vecNeural( + i2v -> i2v.imageFields("img")))); + + var cats = client.collections.use(nsCats); + cats.data.insert(Map.of( + "breed", "ragdoll", + "img", EncodedMedia.IMAGE)); + + var got = cats.query.nearImage(EncodedMedia.IMAGE, + opt -> opt.returnProperties("breed")); + + Assertions.assertThat(got.objects()).hasSize(1).first() + .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP) + .extractingByKey("breed").isEqualTo("ragdoll"); + } + + @Test + public void testFetchObjectsWithFilters() throws IOException { + var nsHats = ns("Hats"); + + client.collections.create(nsHats, + collection -> collection + .properties( + Property.text("colour"), + Property.integer("size"))); + + var hats = client.collections.use(nsHats); + + /* blackHat */ hats.data.insert(Map.of("colour", "black", "size", 6)); + var redHat = hats.data.insert(Map.of("colour", "red", "size", 5)); + var greenHat = hats.data.insert(Map.of("colour", "green", "size", 1)); + var hugeHat = hats.data.insert(Map.of("colour", "orange", "size", 40)); + + var got = hats.query.fetchObjects( + query -> query.filters( + Filter.or( + Filter.property("colour").eq("orange"), + Filter.and( + Filter.property("size").gte(1), + Filter.property("size").lt(6))))); + + Assertions.assertThat(got.objects()) + .extracting(WeaviateObject::uuid) + .containsOnly( + redHat.uuid(), + greenHat.uuid(), + hugeHat.uuid()); + + } + + @Test + public void testFetchObjectsWithSort() throws Exception { + var nsNumbers = ns("Numbers"); + + // Arrange + client.collections.create(nsNumbers, + c -> c.properties(Property.integer("value"))); + + var numbers = client.collections.use(nsNumbers); + + numbers.data.insert(Map.of("value", 1L)); + numbers.data.insert(Map.of("value", 2L)); + numbers.data.insert(Map.of("value", 3L)); + + // Act: sort ascending + var asc = numbers.query.fetchObjects( + q -> q.sort(SortBy.property("value"))); + + Assertions.assertThat(asc.objects()) + .as("value asc") + .hasSize(3) + .extracting(WeaviateObject::properties) + .extracting(object -> object.get("value")) + .containsExactly(1L, 2L, 3L); + + // Act: sort descending + var desc = numbers.query.fetchObjects( + q -> q.sort(SortBy.property("value").desc())); + + Assertions.assertThat(desc.objects()) + .as("value desc") + .hasSize(3) + .extracting(WeaviateObject::properties) + .extracting(object -> object.get("value")) + .containsExactly(3L, 2L, 1L); + } + + @Test + public void testBm25() throws IOException, InterruptedException, ExecutionException { + var nsWords = ns("Words"); + + client.collections.create(nsWords, + collection -> collection + .properties( + Property.text("relevant"), + Property.text("irrelevant"))); + + var words = client.collections.use(nsWords); + + /* notWant */ words.data.insert(Map.of("relevant", "elefant", "irrelevant", "dollar bill")); + var want = words.data.insert(Map.of("relevant", "a dime a dollar", "irrelevant", "euro")); + + var dollarWorlds = words.query.bm25( + "dollar", + bm25 -> bm25.queryProperties("relevant")); + + Assertions.assertThat(dollarWorlds.objects()) + .hasSize(1) + .extracting(WeaviateObject::uuid) + .containsOnly(want.uuid()); + } + + /** + * Minimal test to verify async functionality works as expected. + * We will extend our testing framework at a later stage to automatically + * test both sync/async clients. + */ + @Test + public void testBm25_async() throws Exception, InterruptedException, ExecutionException { + var nsWords = ns("Words"); + + try (final var async = client.async()) { + async.collections.create(nsWords, + collection -> collection + .properties( + Property.text("relevant"), + Property.text("irrelevant"))) + .get(); + + var words = async.collections.use(nsWords); + + /* notWant */ words.data.insert(Map.of("relevant", "elefant", "irrelevant", "dollar bill")).get(); + var want = words.data.insert(Map.of("relevant", "a dime a dollar", "irrelevant", "euro")).get(); + + var dollarWorlds = words.query.bm25( + "dollar", + bm25 -> bm25.queryProperties("relevant")).get(); + + Assertions.assertThat(dollarWorlds.objects()) + .hasSize(1) + .extracting(WeaviateObject::uuid) + .containsOnly(want.uuid()); + } + } + + @Test + public void testNearObject() throws IOException { + // Arrange + var nsAnimals = ns("Animals"); + + client.collections.create(nsAnimals, + collection -> collection + .properties(Property.text("kind")) + .vectorConfig(VectorConfig.text2vecModel2Vec())); + + var animals = client.collections.use(nsAnimals); + + // Terrestrial animals + var cat = animals.data.insert(Map.of("kind", "cat")); + var lion = animals.data.insert(Map.of("kind", "lion")); + // Aquatic animal + animals.data.insert(Map.of("kind", "dolphin")); + + // Act + var terrestrial = animals.query.nearObject(cat.uuid(), + q -> q.excludeSelf().limit(1)); + + // Assert + Assertions.assertThat(terrestrial.objects()) + .hasSize(1) + .extracting(WeaviateObject::uuid) + .containsOnly(lion.uuid()); + } + + @Test + public void testHybrid() throws IOException { + // Arrange + var nsHobbies = ns("Hobbies"); + + client.collections.create(nsHobbies, + collection -> collection + .properties(Property.text("name"), Property.text("description")) + .vectorConfig(VectorConfig.text2vecModel2Vec())); + + var hobbies = client.collections.use(nsHobbies); + + var skiing = hobbies.data.insert(Map.of("name", "skiing", "description", "winter sport")); + hobbies.data.insert(Map.of("name", "jetskiing", "description", "water sport")); + + // Act + var winterSport = hobbies.query.hybrid("winter", + hybrid -> hybrid + .returnMetadata(Metadata.SCORE, Metadata.EXPLAIN_SCORE)); + + // Assert + Assertions.assertThat(winterSport.objects()) + .hasSize(1) + .extracting(WeaviateObject::uuid) + .containsOnly(skiing.uuid()); + + var first = winterSport.objects().get(0); + Assertions.assertThat(first.queryMetadata().score()) + .as("metadata::score").isNotNull(); + Assertions.assertThat(first.queryMetadata().explainScore()) + .as("metadata::explainScore").isNotNull(); + } + + @Test(expected = WeaviateApiException.class) + public void testBadRequest() throws IOException { + // Arrange + var nsThings = ns("Things"); + + client.collections.create(nsThings, + collection -> collection + .properties(Property.text("name")) + .vectorConfig(VectorConfig.text2vecModel2Vec())); + + var things = client.collections.use(nsThings); + var balloon = things.data.insert(Map.of("name", "balloon")); + + things.query.nearObject(balloon.uuid(), q -> q.limit(-1)); + } + + @Test(expected = WeaviateApiException.class) + public void testBadRequest_async() throws Throwable { + // Arrange + var nsThings = ns("Things"); + + try (final var async = client.async()) { + var things = async.collections.create(nsThings, + collection -> collection + .properties(Property.text("name")) + .vectorConfig(VectorConfig.text2vecModel2Vec())) + .join(); + + var balloon = things.data.insert(Map.of("name", "balloon")).join(); + + try { + things.query.nearObject(balloon.uuid(), q -> q.limit(-1)).join(); + } catch (CompletionException e) { + throw e.getCause(); // CompletableFuture exceptions are always wrapped + } + } + } + + @Test + public void test_includeVectors() throws IOException { + // Arrange + var nsThings = ns("Things"); + var things = client.collections.create(nsThings, + c -> c.vectorConfig( + VectorConfig.selfProvided("v1"), + VectorConfig.selfProvided("v2"), + VectorConfig.selfProvided("v3"))); + + var thing_1 = things.data.insert(Map.of(), thing -> thing.vectors( + Vectors.of("v1", new float[] { 1, 2, 3 }), + Vectors.of("v2", new float[] { 4, 5, 6 }), + Vectors.of("v3", new float[] { 7, 8, 9 }))); + + // Act + var got = things.query.fetchObjectById( + thing_1.uuid(), + q -> q.includeVector("v1", "v2")); + + // Assert + Assertions.assertThat(got).get() + .extracting(WeaviateObject::vectors) + .returns(true, v -> v.contains("v1")) + .returns(true, v -> v.contains("v2")) + .returns(false, v -> v.contains("v3")); + } + + @Test + public void testMetadataAll() throws IOException { + // Arrange + var nsThings = ns("Things"); + var things = client.collections.create(nsThings, + c -> c + .properties(Property.text("name")) + .vectorConfig(VectorConfig.text2vecModel2Vec( + t2v -> t2v.sourceProperties("name")))); + + var frisbee = things.data.insert(Map.of("name", "orange disc")); + + // Act + var gotHybrid = things.query.hybrid("orange", q -> q + .queryProperties("name") + .returnMetadata(Metadata.ALL)); + + var gotNearText = things.query.nearText("frisbee", q -> q + .returnMetadata(Metadata.ALL)); + + // Assert + var hybridObject = Assertions.assertThat(gotHybrid.objects()) + .hasSize(1).first().actual(); + var hybridMetadata = hybridObject.queryMetadata(); + + Assertions.assertThat(hybridObject.uuid()).as("uuid").isNotNull().isEqualTo(frisbee.uuid()); + Assertions.assertThat(hybridObject.createdAt()).as("createdAt").isNotNull(); + Assertions.assertThat(hybridObject.lastUpdatedAt()).as("lastUpdateTimeUnix").isNotNull(); + Assertions.assertThat(hybridMetadata.score()).as("score").isNotNull(); + Assertions.assertThat(hybridMetadata.explainScore()).as("explainScore").isNotNull().isNotEqualTo(""); + + var nearTextObject = Assertions.assertThat(gotNearText.objects()) + .hasSize(1).first().actual(); + var metadataNearText = nearTextObject.queryMetadata(); + + Assertions.assertThat(nearTextObject.uuid()).as("uuid").isNotNull().isEqualTo(frisbee.uuid()); + Assertions.assertThat(nearTextObject.createdAt()).as("createdAt").isNotNull(); + Assertions.assertThat(nearTextObject.lastUpdatedAt()).as("lastUpdateTimeUnix").isNotNull(); + Assertions.assertThat(metadataNearText.distance()).as("distance").isNotNull(); + Assertions.assertThat(metadataNearText.certainty()).as("certainty").isNotNull(); + } + + @Test + public void testNearVector_targetVectors() throws IOException { + // Arrange + var nsThings = ns("Things"); + + var things = client.collections.create(nsThings, + c -> c.vectorConfig( + VectorConfig.selfProvided("v1d"), + VectorConfig.selfProvided("v2d", + none -> none + .vectorIndex(Hnsw.of( + hnsw -> hnsw.multiVector(MultiVector.of())))))); + + var thing123 = things.data.insert(Map.of(), thing -> thing.vectors( + Vectors.of("v1d", new float[] { 1, 2, 3 }), + Vectors.of("v2d", new float[][] { { 1, 2, 3 }, { 1, 2, 3 } }))); + + var thing456 = things.data.insertMany(List.of( + WeaviateObject.of(thing -> thing + .vectors( + Vectors.of("v1d", new float[] { 4, 5, 6 }), + Vectors.of("v2d", new float[][] { { 4, 5, 6 }, { 4, 5, 6 } }))))); + Assertions.assertThat(thing456.errors()).as("insert many").isEmpty(); + + // Act + var got123 = things.query.nearVector( + Target.vector("v1d", new float[] { 1, 2, 3 }), + q -> q.limit(1)); + Assertions.assertThat(got123.objects()) + .as("search v1d") + .hasSize(1).extracting(WeaviateObject::uuid) + .containsExactly(thing123.uuid()); + + var got456 = things.query.nearVector( + Target.vector("v2d", new float[][] { { 4, 5, 6 }, { 4, 5, 6 } }), + q -> q.limit(1)); + Assertions.assertThat(got456.objects()) + .as("search v2d") + .hasSize(1).extracting(WeaviateObject::uuid) + .containsExactly(thing456.uuids().get(0)); + } + + @Test + public void testGenerative_bm25() throws IOException { + // Arrange + var nsThings = ns("Things"); + + var things = client.collections.create(nsThings, + c -> c + .properties(Property.text("title")) + .generativeModule(new DummyGenerative()) + .vectorConfig(VectorConfig.text2vecModel2Vec( + t2v -> t2v.sourceProperties("title")))); + + things.data.insertMany( + Map.of("title", "Salad Fork"), + Map.of("title", "Dessert Fork")); + + // Act + var french = things.generate.bm25( + "fork", + bm25 -> bm25.queryProperties("title").limit(2).includeVector(), + generate -> generate + .singlePrompt("translate to French") + .groupedTask("count letters R")); + + // Assert + Assertions.assertThat(french.objects()) + .as("individual results") + .hasSize(2) + .allSatisfy(obj -> { + Assertions.assertThat(obj).as("uuid shorthand") + .returns(obj.uuid(), GenerativeObject::uuid); + Assertions.assertThat(obj).as("vectors shorthand") + .returns(obj.vectors(), GenerativeObject::vectors); + }) + .extracting(GenerativeObject::generative) + .allSatisfy(generated -> { + Assertions.assertThat(generated.text()).isNotBlank(); + }); + + Assertions.assertThat(french.generative()) + .as("summary") + .extracting(TaskOutput::text, InstanceOfAssertFactories.STRING) + .isNotBlank(); + } + + @Test + public void testGenerative_bm25_groupBy() throws IOException { + // Arrange + var nsThings = ns("Things"); + + var things = client.collections.create(nsThings, + c -> c + .properties(Property.text("title")) + .generativeModule(new DummyGenerative()) + .vectorConfig(VectorConfig.text2vecModel2Vec( + t2v -> t2v.sourceProperties("title")))); + + things.data.insertMany( + Map.of("title", "Salad Fork"), + Map.of("title", "Dessert Fork")); + + // Act + var french = things.generate.bm25( + "fork", + bm25 -> bm25.queryProperties("title").limit(2), + generate -> generate + .singlePrompt("translate to French") + .groupedTask("count letters R"), + GroupBy.property("title", 5, 5)); + + // Assert + Assertions.assertThat(french.objects()) + .as("individual results") + .hasSize(2); + + Assertions.assertThat(french.groups()) + .as("grouped results") + .hasSize(2) + .allSatisfy((groupName, group) -> { + Assertions.assertThat(group.objects()) + .describedAs("objects in group %s", groupName) + .hasSize(1); + + Assertions.assertThat(group.generative()) + .describedAs("summary group %s", groupName) + .extracting(TaskOutput::text, InstanceOfAssertFactories.STRING) + .isNotBlank(); + + }); + + Assertions.assertThat(french.generative()) + .as("summary") + .extracting(TaskOutput::text, InstanceOfAssertFactories.STRING) + .isNotBlank(); + } + + @Test + public void test_filterIsNull() throws IOException { + // Arrange + var nsNulls = ns("Nulls"); + + var nulls = client.collections.create(nsNulls, + c -> c + .invertedIndex(idx -> idx.indexNulls(true)) + .properties(Property.text("never"))); + + var inserted = nulls.data.insertMany(Map.of(), Map.of("never", "notNull")); + Assertions.assertThat(inserted.errors()).isEmpty(); + + // Act + var isNull = nulls.query.fetchObjects(q -> q.filters(Filter.property("never").isNull())); + var isNotNull = nulls.query.fetchObjects(q -> q.filters(Filter.property("never").isNotNull())); + + // Assert + var isNull_1 = Assertions.assertThat(isNull.objects()) + .as("objects WHERE never IS NULL") + .hasSize(1).first().actual(); + var isNotNull_1 = Assertions.assertThat(isNotNull.objects()) + .as("objects WHERE never IS NOT NULL") + .hasSize(1).first().actual(); + Assertions.assertThat(isNull_1).isNotEqualTo(isNotNull_1); + } + + @Test + public void test_filterCreateUpdateTime() throws IOException { + // Arrange + var now = OffsetDateTime.now().minusHours(1); + var nsCounter = ns("Counter"); + + var counter = client.collections.create(nsCounter, + c -> c + .invertedIndex(idx -> idx.indexTimestamps(true)) + .properties(Property.integer("count"))); + + counter.data.insert(Map.of("count", 0)); + + // Act + var beforeNow = counter.query.fetchObjects(q -> q.filters(Filter.createdAt().lt(now))); + var afterNow = counter.query.fetchObjects(q -> q.filters(Filter.createdAt().gt(now))); + + // Assert + Assertions.assertThat(beforeNow.objects()).isEmpty(); + Assertions.assertThat(afterNow.objects()).hasSize(1); + } + + @Test + public void teset_filterPropertyLength() throws IOException { + // Arrange + var nsStrings = ns("Strings"); + + var strings = client.collections.create(nsStrings, c -> c + .invertedIndex(idx -> idx.indexPropertyLength(true)) + .properties(Property.text("letters"))); + strings.data.insertMany(Map.of("letters", "abc"), Map.of("letters", "abcd"), Map.of("letters", "a")); + + // Act + var got = strings.query.fetchObjects(q -> q.filters(Filter.propertyLen("letters").gte(3))); + + // Assertions + Assertions.assertThat(got.objects()).hasSize(2); + } + + /** + * Ensure the client respects server's configuration for max gRPC size: + * we create a server with 1-byte message size and try to send a large payload + * there. If the channel is configured correctly, it will refuse to send it. + */ + @Test + @Ignore("Exception thrown by gRPC transport causes a deadlock") + public void test_maxGrpcMessageSize() throws Exception { + var w = Weaviate.custom().withGrpcMaxMessageSize(1).build(); + var nsHugeVectors = ns("HugeVectors"); + + try (final var _client = w.getClient()) { + var huge = _client.collections.create(nsHugeVectors, c -> c + .vectorConfig(VectorConfig.selfProvided())); + + final var vector = randomVector(5000, -.01f, .01f); + final WeaviateObject> hugeObject = WeaviateObject.of( + obj -> obj.vectors(Vectors.of(vector))); + + Assertions.assertThatThrownBy(() -> { + // insertMany to route this request through gRPC. + huge.data.insertMany(hugeObject); + }).isInstanceOf(io.grpc.StatusRuntimeException.class); + } + } + + @Test + public void test_rerankQueries() throws IOException { + // Arrange + var nsThigns = ns("Things"); + + var things = client.collections.create(nsThigns, + c -> c + .properties(Property.text("title"), Property.integer("price")) + .vectorConfig(VectorConfig.text2vecModel2Vec( + t2v -> t2v.sourceProperties("title", "price"))) + .rerankerModules(new DummyReranker())); + + things.data.insertMany( + Map.of("title", "Ergonomic chair", "price", 269), + Map.of("title", "Height-adjustable desk", "price", 349)); + + // Act + var got = things.query.nearText( + "office supplies", + nt -> nt.rerank(Rerank.by("price", + rank -> rank.query("cheaper first")))); + + // Assert: ranking not important really, just that the request was valid. + Assertions.assertThat(got.objects()).hasSize(2); + } +} diff --git a/src/it/java/io/weaviate/integration/TenantsITest.java b/src/it/java/io/weaviate/integration/TenantsITest.java new file mode 100644 index 000000000..c765ae080 --- /dev/null +++ b/src/it/java/io/weaviate/integration/TenantsITest.java @@ -0,0 +1,74 @@ +package io.weaviate.integration; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.tenants.Tenant; +import io.weaviate.containers.Container; +import io.weaviate.containers.Container.ContainerGroup; +import io.weaviate.containers.MinIo; +import io.weaviate.containers.Weaviate; + +public class TenantsITest extends ConcurrentTest { + private static final ContainerGroup compose = Container.compose( + Weaviate.custom() + .withOffloadS3(MinIo.ACCESS_KEY, MinIo.SECRET_KEY) + .build(), + Container.MINIO); + + private static final WeaviateClient client = compose.getClient(); + + @Test + public void test_tenantLifecycle() throws Exception { + var nsThings = ns("Things"); + + client.collections.create( + nsThings, c -> c + .multiTenancy(mt -> mt + .autoTenantCreation(false) + .autoTenantActivation(false))); + + var things = client.collections.use(nsThings); + + // No tenants at first + Assertions.assertThat(things.tenants.list()).as("no tenants initially").isEmpty(); + + var allison = Tenant.active("active-allison"); + var isaac = Tenant.inactive("inactive-isaac"); + var owen = Tenant.inactive("offloaded-owen"); + + things.tenants.create(allison, isaac, owen); + + // Collection has 2 tenants creted just now. + Assertions.assertThat(things.tenants.list()).as("list created tenants").hasSize(3); + Assertions.assertThat(things.tenants.exists(allison.name())) + .describedAs("%s exists", allison.name()).isTrue(); + Assertions.assertThat(things.tenants.exists(isaac.name())) + .describedAs("%s exists", isaac.name()).isTrue(); + Assertions.assertThat(things.tenants.exists(owen.name())) + .describedAs("%s exists", owen.name()).isTrue(); + + things.tenants.activate(isaac.name()); + eventually(() -> things.tenants.get(isaac.name()).get().isActive(), + 200, 2, isaac.name() + " not activated"); + + things.tenants.deactivate(allison.name()); + eventually(() -> things.tenants.get(allison.name()).get().isInactive(), + 200, 2, allison.name() + " not deactivated"); + + things.tenants.offload(owen.name()); + eventually(() -> things.tenants.get(owen.name()).get().isOffloaded(), + 200, 2, owen.name() + " not offloaded"); + + things.tenants.delete(allison.name(), isaac.name(), owen.name()); + Assertions.assertThat(things.tenants.list()).as("no tenants after deletion").isEmpty(); + Assertions.assertThat(things.tenants.exists(allison.name())) + .describedAs("%s not exists", allison.name()).isFalse(); + Assertions.assertThat(things.tenants.exists(isaac.name())) + .describedAs("%s not exists", isaac.name()).isFalse(); + Assertions.assertThat(things.tenants.exists(owen.name())) + .describedAs("%s not exists", owen.name()).isFalse(); + } +} diff --git a/src/it/java/io/weaviate/integration/VectorizersITest.java b/src/it/java/io/weaviate/integration/VectorizersITest.java new file mode 100644 index 000000000..69c6e50a1 --- /dev/null +++ b/src/it/java/io/weaviate/integration/VectorizersITest.java @@ -0,0 +1,81 @@ +package io.weaviate.integration; + +import java.io.IOException; +import java.util.Map; + +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.rules.TestRule; + +import io.weaviate.ConcurrentTest; +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.query.FetchObjectById; +import io.weaviate.containers.Container; +import io.weaviate.containers.Model2Vec; +import io.weaviate.containers.Weaviate; + +import static org.assertj.core.api.Assertions.assertThat; + +public class VectorizersITest extends ConcurrentTest { + private static final Container.ContainerGroup compose = Container.compose( + Weaviate.custom() + .withModel2VecUrl(Model2Vec.URL) + .build(), + Container.MODEL2VEC); + @ClassRule // Bind containers to the lifetime of the test + public static final TestRule _rule = compose.asTestRule(); + private static final WeaviateClient client = compose.getClient(); + + @Test + public void testVectorizerModel2VecPropeties() throws IOException { + var collectionName = ns("Model2Vec2NamedVectors"); + client.collections.create(collectionName, + col -> col + .properties(Property.text("name"), Property.text("author")) + .vectorConfig( + VectorConfig.text2vecModel2Vec("name", v -> v.sourceProperties("name")), + VectorConfig.text2vecModel2Vec("author", v -> v.sourceProperties("author")) + ) + ); + + var model2vec = client.collections.use(collectionName); + assertThat(model2vec).isNotNull(); + + String uuid1 = "00000000-0000-0000-0000-000000000001"; + WeaviateObject> obj1 = WeaviateObject.of(o -> + o.properties(Map.of("name", "Dune", "author", "Frank Herbert")).uuid(uuid1) + ); + String uuid2 = "00000000-0000-0000-0000-000000000002"; + WeaviateObject> obj2 = WeaviateObject.of(o -> + o.properties(Map.of("name", "same content", "author", "same content")).uuid(uuid2) + ); + + var resp = model2vec.data.insertMany(obj1, obj2); + assertThat(resp).isNotNull().satisfies(s -> { + assertThat(s.errors()).isEmpty(); + }); + + var o1 = model2vec.query.fetchObjectById(uuid1, FetchObjectById.Builder::includeVector); + // Assert that for object1 we have generated 2 different vectors + assertThat(o1).get() + .extracting(WeaviateObject::vectors) + .satisfies(v -> { + assertThat(v.getSingle("name")).isNotEmpty(); + assertThat(v.getSingle("author")).isNotEmpty(); + assertThat(v.getSingle("name")).isNotEqualTo(v.getSingle("author")); + }); + + var o2 = model2vec.query.fetchObjectById(uuid2, FetchObjectById.Builder::includeVector); + // Assert that for object2 we have generated same vectors + assertThat(o2).get() + .extracting(WeaviateObject::vectors) + .satisfies(v -> { + assertThat(v.getSingle("name")).isNotEmpty(); + assertThat(v.getSingle("author")).isNotEmpty(); + assertThat(v.getSingle("name")).isEqualTo(v.getSingle("author")); + }); + } +} diff --git a/src/main/java/io/weaviate/client/Config.java b/src/main/java/io/weaviate/client/Config.java deleted file mode 100644 index 0066bb6f0..000000000 --- a/src/main/java/io/weaviate/client/Config.java +++ /dev/null @@ -1,115 +0,0 @@ -package io.weaviate.client; - -import java.util.HashMap; -import java.util.Map; - -import lombok.Getter; -import lombok.Setter; - -public class Config { - - private static final int DEFAULT_TIMEOUT_SECONDS = 60; - @Getter - private final String scheme; - @Getter - private final String host; - private final String version; - @Getter - private final Map headers = new HashMap<>(); - @Getter - private final int connectionTimeout; - @Getter - private final int connectionRequestTimeout; - @Getter - private final int socketTimeout; - @Getter - private String proxyHost; - @Getter - private int proxyPort; - @Getter - private String proxyScheme; - @Getter - @Setter - private boolean gRPCSecured; - @Getter - @Setter - private String gRPCHost; - - public Config(String scheme, String host) { - this(scheme, host, null, DEFAULT_TIMEOUT_SECONDS, DEFAULT_TIMEOUT_SECONDS, DEFAULT_TIMEOUT_SECONDS); - } - - public Config(String scheme, String host, boolean gRPCSecured, String gRPCHost) { - this(scheme, host, null, DEFAULT_TIMEOUT_SECONDS, gRPCSecured, gRPCHost); - } - - public Config(String scheme, String host, Map headers) { - this(scheme, host, headers, DEFAULT_TIMEOUT_SECONDS, DEFAULT_TIMEOUT_SECONDS, DEFAULT_TIMEOUT_SECONDS); - } - - public Config(String scheme, String host, boolean gRPCSecured, String gRPCHost, Map headers) { - this(scheme, host, headers, DEFAULT_TIMEOUT_SECONDS, gRPCSecured, gRPCHost); - } - - public Config(String scheme, String host, Map headers, int connectionTimeout, - int connectionRequestTimeout, int socketTimeout) { - this.scheme = scheme; - this.host = host; - this.version = "v1"; - this.setHeaders(headers); - this.connectionTimeout = connectionTimeout; - this.connectionRequestTimeout = connectionRequestTimeout; - this.socketTimeout = socketTimeout; - } - - public Config(String scheme, String host, Map headers, int timeout) { - this(scheme, host, headers, timeout, false, null); - } - - public Config(String scheme, String host, Map headers, int timeout, boolean gRPCSecured, - String gRPCHost) { - this.scheme = scheme; - this.host = host; - this.version = "v1"; - this.setHeaders(headers); - this.connectionTimeout = timeout; - this.connectionRequestTimeout = timeout; - this.socketTimeout = timeout; - this.gRPCSecured = gRPCSecured; - this.gRPCHost = gRPCHost; - } - - public String getBaseURL() { - return scheme + "://" + host + "/" + version; - } - - public void setProxy(String proxyHost, int proxyPort, String proxyScheme) { - this.proxyHost = proxyHost; - this.proxyPort = proxyPort; - this.proxyScheme = proxyScheme; - } - - public boolean useGRPC() { - return this.gRPCHost != null && !this.gRPCHost.trim().isEmpty(); - } - - /** - * setHeader adds a new header to the headers map. An older entry - * with the same key will be overwritten. - */ - void setHeader(String key, String value) { - this.headers.put(key, value); - } - - /** - * setHeaders adds all entries to the headers map. Older entries - * with the same key will be overwritten. - * - * Passing a null map is safe, as it will be ignored. - */ - void setHeaders(Map headers) { - if (headers != null) { - this.headers.putAll(headers); - } - } -} diff --git a/src/main/java/io/weaviate/client/WeaviateAuthClient.java b/src/main/java/io/weaviate/client/WeaviateAuthClient.java deleted file mode 100644 index 31b8adea4..000000000 --- a/src/main/java/io/weaviate/client/WeaviateAuthClient.java +++ /dev/null @@ -1,66 +0,0 @@ -package io.weaviate.client; - -import java.util.List; - -import io.weaviate.client.v1.auth.ApiKeyFlow; -import io.weaviate.client.v1.auth.BearerTokenFlow; -import io.weaviate.client.v1.auth.ClientCredentialsFlow; -import io.weaviate.client.v1.auth.ResourceOwnerPasswordFlow; -import io.weaviate.client.v1.auth.exception.AuthException; - -public class WeaviateAuthClient { - - public static WeaviateClient clientCredentials(Config config, String clientSecret, List scopes) - throws AuthException { - ClientCredentialsFlow clientCredentialsFlow = new ClientCredentialsFlow(clientSecret); - return clientCredentialsFlow.getAuthClient(config, scopes); - } - - public static WeaviateClient clientPassword(Config config, String username, String password, List scopes) - throws AuthException { - ResourceOwnerPasswordFlow resourceOwnerPasswordFlow = new ResourceOwnerPasswordFlow(username, password); - return resourceOwnerPasswordFlow.getAuthClient(config, scopes); - } - - public static WeaviateClient bearerToken(Config config, String accessToken, long accessTokenLifetime, - String refreshToken) throws AuthException { - BearerTokenFlow bearerTokenFlow = new BearerTokenFlow(accessToken, accessTokenLifetime, refreshToken); - return bearerTokenFlow.getAuthClient(config, null); - } - - /** - * apiKey returns a new WeaviateClient with ApiKey token provider. - * If the host is a Weaviate domain, it also adds headers necessary - * for authenticating to Weaviate Embeddings service. - */ - public static WeaviateClient apiKey(Config config, String apiKey) throws AuthException { - ApiKeyFlow flow = new ApiKeyFlow(apiKey); - if (isWeaviateDomain(config.getHost())) { - addWeaviateHeaders(config, apiKey); - } - return flow.getAuthClient(config); - } - - private static final String HEADER_X_WEAVIATE_API_KEY = "X-Weaviate-Api-Key"; - private static final String HEADER_X_WEAVIATE_CLUSTER_URL = "X-Weaviate-Cluster-URL"; - - /** - * addWeaviateHeaders sets headers necessary for authenticating - * with Weaviate Embedding service. - */ - private static void addWeaviateHeaders(Config config, String apiKey) { - config.setHeader(HEADER_X_WEAVIATE_API_KEY, apiKey); - config.setHeader(HEADER_X_WEAVIATE_CLUSTER_URL, "https://" + config.getHost()); - } - - /** - * isWeaviateDomain returns true if the host matches weaviate.io, - * semi.technology, or weaviate.cloud domain. - */ - private static boolean isWeaviateDomain(String host) { - String lower = host.toLowerCase(); - return lower.contains("weaviate.io") || - lower.contains("semi.technology") || - lower.contains("weaviate.cloud"); - } -} diff --git a/src/main/java/io/weaviate/client/WeaviateClient.java b/src/main/java/io/weaviate/client/WeaviateClient.java deleted file mode 100644 index 5791455e7..000000000 --- a/src/main/java/io/weaviate/client/WeaviateClient.java +++ /dev/null @@ -1,132 +0,0 @@ -package io.weaviate.client; - -import java.util.Optional; - -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.http.builder.HttpApacheClientBuilder; -import io.weaviate.client.base.http.impl.CommonsHttpClientImpl; -import io.weaviate.client.base.util.DbVersionProvider; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.aliases.Aliases; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.Backup; -import io.weaviate.client.v1.batch.Batch; -import io.weaviate.client.v1.classifications.Classifications; -import io.weaviate.client.v1.cluster.Cluster; -import io.weaviate.client.v1.contextionary.Contextionary; -import io.weaviate.client.v1.data.Data; -import io.weaviate.client.v1.graphql.GraphQL; -import io.weaviate.client.v1.groups.Groups; -import io.weaviate.client.v1.grpc.GRPC; -import io.weaviate.client.v1.misc.Misc; -import io.weaviate.client.v1.misc.api.MetaGetter; -import io.weaviate.client.v1.rbac.Roles; -import io.weaviate.client.v1.schema.Schema; -import io.weaviate.client.v1.users.Users; - -public class WeaviateClient { - private final Config config; - private final DbVersionProvider dbVersionProvider; - private final DbVersionSupport dbVersionSupport; - private final GrpcVersionSupport grpcVersionSupport; - private final HttpClient httpClient; - private final AccessTokenProvider tokenProvider; - - public final io.weaviate.client.v1.experimental.Collections collections; - public final io.weaviate.client.v1.experimental.DataClient datax; - - public WeaviateClient(Config config) { - this(config, new CommonsHttpClientImpl(config.getHeaders(), null, HttpApacheClientBuilder.build(config)), null); - } - - public WeaviateClient(Config config, AccessTokenProvider tokenProvider) { - this(config, new CommonsHttpClientImpl(config.getHeaders(), tokenProvider, HttpApacheClientBuilder.build(config)), - tokenProvider); - } - - public WeaviateClient(Config config, HttpClient httpClient, AccessTokenProvider tokenProvider) { - this.config = config; - this.httpClient = httpClient; - dbVersionProvider = initDbVersionProvider(); - dbVersionSupport = new DbVersionSupport(dbVersionProvider); - grpcVersionSupport = new GrpcVersionSupport(dbVersionProvider); - this.tokenProvider = tokenProvider; - - this.collections = new io.weaviate.client.v1.experimental.Collections(config, tokenProvider); - this.datax = new io.weaviate.client.v1.experimental.DataClient(config, httpClient, tokenProvider, dbVersionSupport, - grpcVersionSupport, new Data(httpClient, config, dbVersionSupport)); - } - - public WeaviateAsyncClient async() { - return new WeaviateAsyncClient(config, tokenProvider); - } - - public Misc misc() { - return new Misc(httpClient, config, dbVersionProvider); - } - - public Schema schema() { - return new Schema(httpClient, config, dbVersionSupport); - } - - public Data data() { - dbVersionProvider.refresh(); - return new Data(httpClient, config, dbVersionSupport); - } - - public Batch batch() { - dbVersionProvider.refresh(); - return new Batch(httpClient, config, dbVersionSupport, grpcVersionSupport, tokenProvider, data()); - } - - public Backup backup() { - return new Backup(httpClient, config); - } - - public Contextionary c11y() { - return new Contextionary(httpClient, config); - } - - public Classifications classifications() { - return new Classifications(httpClient, config); - } - - public Cluster cluster() { - return new Cluster(httpClient, config); - } - - public GraphQL graphQL() { - return new GraphQL(httpClient, config); - } - - public GRPC gRPC() { - return new GRPC(httpClient, config, tokenProvider); - } - - public Roles roles() { - return new Roles(httpClient, config); - } - - public Users users() { - return new Users(httpClient, config); - } - - public Groups groups() { - return new Groups(httpClient, config); - } - - public Aliases alias() { - return new Aliases(httpClient, config); - } - - private DbVersionProvider initDbVersionProvider() { - MetaGetter metaGetter = new Misc(httpClient, config, null).metaGetter(); - DbVersionProvider.VersionGetter getter = () -> Optional.ofNullable(metaGetter.run()) - .filter(result -> !result.hasErrors()) - .map(result -> result.getResult().getVersion()); - - return new DbVersionProvider(getter); - } -} diff --git a/src/main/java/io/weaviate/client/base/AsyncBaseClient.java b/src/main/java/io/weaviate/client/base/AsyncBaseClient.java deleted file mode 100644 index 399afbf0f..000000000 --- a/src/main/java/io/weaviate/client/base/AsyncBaseClient.java +++ /dev/null @@ -1,112 +0,0 @@ -package io.weaviate.client.base; - -import java.util.Map; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.async.methods.SimpleHttpRequest; -import org.apache.hc.client5.http.async.methods.SimpleRequestProducer; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpHeaders; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.http.async.WeaviateResponseConsumer; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public abstract class AsyncBaseClient { - protected final CloseableHttpAsyncClient client; - private final Config config; - private final Serializer serializer; - private final AccessTokenProvider tokenProvider; - - public AsyncBaseClient(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - this.client = client; - this.config = config; - this.tokenProvider = tokenProvider; - this.serializer = new Serializer(); - } - - protected Future> sendGetRequest(String endpoint, Class classOfT, FutureCallback> callback) { - return sendRequest(endpoint, null, "GET", classOfT, callback, null); - } - - protected Future> sendGetRequest(String endpoint, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, null, "GET", null, callback, parser); - } - - protected Future> sendPostRequest(String endpoint, Object payload, Class classOfT, - FutureCallback> callback) { - return sendRequest(endpoint, payload, "POST", classOfT, callback, null); - } - - protected Future> sendPostRequest(String endpoint, Object payload, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, payload, "POST", null, callback, parser); - } - - protected Future> sendPutRequest(String endpoint, Object payload, Class classOfT, - FutureCallback> callback) { - return sendRequest(endpoint, payload, "PUT", classOfT, callback, null); - } - - protected Future> sendPutRequest(String endpoint, Object payload, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, payload, "PUT", null, callback, parser); - } - - protected Future> sendPatchRequest(String endpoint, Object payload, Class classOfT, - FutureCallback> callback) { - return sendRequest(endpoint, payload, "PATCH", classOfT, callback, null); - } - - protected Future> sendPatchRequest(String endpoint, Object payload, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, payload, "PATCH", null, callback, parser); - } - - protected Future> sendDeleteRequest(String endpoint, Object payload, Class classOfT, - FutureCallback> callback) { - return sendRequest(endpoint, payload, "DELETE", classOfT, callback, null); - } - - protected Future> sendDeleteRequest(String endpoint, Object payload, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, payload, "DELETE", null, callback, parser); - } - - protected Future> sendHeadRequest(String endpoint, Class classOfT, FutureCallback> callback) { - return sendRequest(endpoint, null, "HEAD", classOfT, callback, null); - } - - protected Future> sendHeadRequest(String endpoint, FutureCallback> callback, - ResponseParser parser) { - return sendRequest(endpoint, null, "HEAD", null, callback, parser); - } - - private Future> sendRequest(String endpoint, Object payload, String method, Class classOfT, - FutureCallback> callback, ResponseParser parser) { - return client.execute(SimpleRequestProducer.create(getRequest(endpoint, payload, method)), - new WeaviateResponseConsumer<>(classOfT, parser), callback); - } - - protected SimpleHttpRequest getRequest(String endpoint, Object payload, String method) { - SimpleHttpRequest req = new SimpleHttpRequest(method, String.format("%s%s", config.getBaseURL(), endpoint)); - req.addHeader(HttpHeaders.ACCEPT, "*/*"); - req.addHeader(HttpHeaders.CONTENT_TYPE, "application/json"); - if (config.getHeaders() != null) { - for (Map.Entry h : config.getHeaders().entrySet()) { - req.addHeader(h.getKey(), h.getValue()); - } - } - if (tokenProvider != null) { - req.addHeader("Authorization", String.format("Bearer %s", tokenProvider.getAccessToken())); - } - if (payload != null) { - req.setBody(serializer.toJsonString(payload), ContentType.APPLICATION_JSON); - } - return req; - } -} diff --git a/src/main/java/io/weaviate/client/base/AsyncBaseGraphQLClient.java b/src/main/java/io/weaviate/client/base/AsyncBaseGraphQLClient.java deleted file mode 100644 index 0500fc314..000000000 --- a/src/main/java/io/weaviate/client/base/AsyncBaseGraphQLClient.java +++ /dev/null @@ -1,21 +0,0 @@ -package io.weaviate.client.base; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.async.WeaviateGraphQLTypedResponseConsumer; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.async.methods.SimpleRequestProducer; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class AsyncBaseGraphQLClient extends AsyncBaseClient { - public AsyncBaseGraphQLClient(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - protected Future>> sendGraphQLTypedRequest(Object payload, Class classOfC, - FutureCallback>> callback) { - return client.execute(SimpleRequestProducer.create(getRequest("/graphql", payload, "POST")), new WeaviateGraphQLTypedResponseConsumer<>(classOfC), callback); - } -} diff --git a/src/main/java/io/weaviate/client/base/AsyncClientResult.java b/src/main/java/io/weaviate/client/base/AsyncClientResult.java deleted file mode 100644 index 574b0902e..000000000 --- a/src/main/java/io/weaviate/client/base/AsyncClientResult.java +++ /dev/null @@ -1,13 +0,0 @@ -package io.weaviate.client.base; - -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public interface AsyncClientResult { - default Future> run() { - return run(null); - } - - Future> run(FutureCallback> callback); -} diff --git a/src/main/java/io/weaviate/client/base/BaseClient.java b/src/main/java/io/weaviate/client/base/BaseClient.java deleted file mode 100644 index c98549f55..000000000 --- a/src/main/java/io/weaviate/client/base/BaseClient.java +++ /dev/null @@ -1,92 +0,0 @@ -package io.weaviate.client.base; - -import java.util.Collections; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.http.HttpResponse; - -public abstract class BaseClient { - private final HttpClient client; - protected final Config config; - protected final Serializer serializer; - - public BaseClient(HttpClient client, Config config) { - this.config = config; - this.client = client; - this.serializer = new Serializer(); - } - - protected Response sendGetRequest(String endpoint, Class classOfT) { - return sendRequest(endpoint, null, "GET", classOfT); - } - - protected Response sendPostRequest(String endpoint, Object payload, Class classOfT) { - return sendRequest(endpoint, payload, "POST", classOfT); - } - - protected Response sendPutRequest(String endpoint, Object payload, Class classOfT) { - return sendRequest(endpoint, payload, "PUT", classOfT); - } - - protected Response sendPatchRequest(String endpoint, Object payload, Class classOfT) { - return sendRequest(endpoint, payload, "PATCH", classOfT); - } - - protected Response sendDeleteRequest(String endpoint, Object payload, Class classOfT) { - return sendRequest(endpoint, payload, "DELETE", classOfT); - } - - protected Response sendHeadRequest(String endpoint, Class classOfT) { - return sendRequest(endpoint, null, "HEAD", classOfT); - } - - private Response sendRequest(String endpoint, Object payload, String method, Class classOfT) { - try { - HttpResponse response = this.sendHttpRequest(endpoint, payload, method); - int statusCode = response.getStatusCode(); - String responseBody = response.getBody(); - if (statusCode < 399) { - return new Response<>(statusCode, toResponse(responseBody, classOfT), null); - } - return new Response<>(statusCode, null, toResponse(responseBody, WeaviateErrorResponse.class)); - } catch (Exception e) { - WeaviateErrorResponse errors = getWeaviateErrorResponse(e); - return new Response<>(0, null, errors); - } - } - - protected HttpResponse sendHttpRequest(String endpoint, Object payload, String method) throws Exception { - String address = config.getBaseURL() + endpoint; - String json = toJsonString(payload); - if (method.equals("POST")) { - return client.sendPostRequest(address, json); - } - if (method.equals("PUT")) { - return client.sendPutRequest(address, json); - } - if (method.equals("PATCH")) { - return client.sendPatchRequest(address, json); - } - if (method.equals("DELETE")) { - return client.sendDeleteRequest(address, json); - } - if (method.equals("HEAD")) { - return client.sendHeadRequest(address); - } - return client.sendGetRequest(address); - } - - protected C toResponse(String response, Class classOfT) { - return serializer.toResponse(response, classOfT); - } - - private String toJsonString(Object object) { - return serializer.toJsonString(object); - } - - protected WeaviateErrorResponse getWeaviateErrorResponse(Exception e) { - WeaviateErrorMessage error = WeaviateErrorMessage.builder().message(e.getMessage()).throwable(e).build(); - return WeaviateErrorResponse.builder().error(Collections.singletonList(error)).build(); - } -} diff --git a/src/main/java/io/weaviate/client/base/BaseGraphQLClient.java b/src/main/java/io/weaviate/client/base/BaseGraphQLClient.java deleted file mode 100644 index 15eda6331..000000000 --- a/src/main/java/io/weaviate/client/base/BaseGraphQLClient.java +++ /dev/null @@ -1,35 +0,0 @@ -package io.weaviate.client.base; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.http.HttpResponse; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; - -public abstract class BaseGraphQLClient extends BaseClient { - public BaseGraphQLClient(HttpClient client, Config config) { - super(client, config); - } - - private GraphQLTypedResponse toResponseTyped(String response, Class classOfC) { - return serializer.toGraphQLTypedResponse(response, classOfC); - } - - protected Response> sendGraphQLTypedRequest(Object payload, Class classOfC) { - try { - HttpResponse response = this.sendHttpRequest("/graphql", payload, "POST"); - int statusCode = response.getStatusCode(); - String responseBody = response.getBody(); - - if (statusCode < 399) { - GraphQLTypedResponse body = toResponseTyped(responseBody, classOfC); - return new Response<>(statusCode, body, null); - } - - WeaviateErrorResponse error = toResponse(responseBody, WeaviateErrorResponse.class); - return new Response<>(statusCode, null, error); - } catch (Exception e) { - WeaviateErrorResponse errors = getWeaviateErrorResponse(e); - return new Response<>(0, null, errors); - } - } -} diff --git a/src/main/java/io/weaviate/client/base/ClientResult.java b/src/main/java/io/weaviate/client/base/ClientResult.java deleted file mode 100644 index b426d702b..000000000 --- a/src/main/java/io/weaviate/client/base/ClientResult.java +++ /dev/null @@ -1,5 +0,0 @@ -package io.weaviate.client.base; - -public interface ClientResult { - Result run(); -} diff --git a/src/main/java/io/weaviate/client/base/Response.java b/src/main/java/io/weaviate/client/base/Response.java deleted file mode 100644 index 84171e365..000000000 --- a/src/main/java/io/weaviate/client/base/Response.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.weaviate.client.base; - -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import java.util.List; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.experimental.FieldDefaults; - -@Getter -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Response { - int statusCode; - T body; - WeaviateErrorResponse errors; - - public Response(int statusCode, T body, WeaviateErrorResponse errors) { - this.statusCode = statusCode; - this.body = body; - if (body instanceof GraphQLResponse) { - this.errors = getWeaviateGraphQLErrorResponse((GraphQLResponse) body, statusCode);; - } else { - this.errors = errors; - } - } - - /** - * Extract errors from {@link WeaviateErrorResponse} from a GraphQL response body. - * - * @param gql GraphQL response body. - * @param code HTTP status code to pass in the {@link WeaviateErrorResponse}. - * @return Error response to be returned to the caller. - */ - private WeaviateErrorResponse getWeaviateGraphQLErrorResponse(GraphQLResponse gql, int code) { - List messages = gql.errorMessages(); - if (messages == null || messages.isEmpty()) { - return null; - } - return WeaviateErrorResponse.builder().code(code).error(gql.errorMessages()).build(); - } -} diff --git a/src/main/java/io/weaviate/client/base/Result.java b/src/main/java/io/weaviate/client/base/Result.java deleted file mode 100644 index f859486dd..000000000 --- a/src/main/java/io/weaviate/client/base/Result.java +++ /dev/null @@ -1,260 +0,0 @@ -package io.weaviate.client.base; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Objects; -import java.util.Optional; -import java.util.concurrent.Future; -import java.util.function.Function; -import java.util.stream.Collectors; - -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.base.http.async.ResponseParser; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Result { - T result; - WeaviateError error; - - public Result(Response response) { - this(response.getStatusCode(), response.getBody(), response.getErrors()); - } - - public Result(Response response, T body) { - this(response.getStatusCode(), body, response.getErrors()); - } - - public Result(int statusCode, T body, WeaviateErrorResponse errors) { - if (errors != null && errors.getError() != null) { - List items = errors.getError().stream().filter(Objects::nonNull) - .collect(Collectors.toList()); - this.error = new WeaviateError(statusCode, items); - this.result = body; - } else if (errors != null && errors.getMessage() != null) { - this.error = new WeaviateError(statusCode, - Collections.singletonList(WeaviateErrorMessage.builder().message(errors.getMessage()).build())); - this.result = body; - } else { - this.result = body; - this.error = null; - } - } - - public boolean hasErrors() { - return this.error != null; - } - - /** - * Copy the Result object with a null body, preserving only the status code and - * the error message. - * - * @param Would-be response type. It's required for type safety, but can be - * anything since the body is always set to null. - * @return A copy of this Result. - */ - public Result toErrorResult() { - return new Result<>(this.error.getStatusCode(), null, - WeaviateErrorResponse.builder().error(this.error.getMessages()).build()); - } - - /** - * Apply {@code map} function to {@code Response::getBody} and return - * {@link Result} with the transformed body. - * - *

- * A {@code null}-body is passed as-is. - * - *

- * Usage: - * - *

{@code @Override
-   * public Result run() {
-   *   // Deserializes into Person.class but returns Person's firstName or null.
-   *   return Result.map(sendGetRequest("/person", Person.class), Person::getFirstName);
-   * }
-   * }
- */ - public static Result map(Response response, Function map) { - R body = response.getBody() != null - ? map.apply(response.getBody()) - : null; - return new Result<>(response, body); - } - - /** - * Apply {@code map} function to {@code Response::getBody} and return - * {@link Future} with the transformed body. - * - *

- * A {@code null}-body is passed as-is. - * - *

- * Usage: - * - *

{@code @Override
-   * public Future run(FutureCallback> callback) {
-   *   // Deserializes into Person.class but returns Person's firstName or null.
-   *   return sendGetRequest("/person", callback, Result.mapParser(Person.class, Person::getFirstName));
-   * }
-   * }
- */ - public static ResponseParser mapParser(Class cls, Function map) { - return new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, cls); - return Result.map(resp, map); - } - }; - } - - /** - * Convert {@code T[]} response to a {@code List} response. - * This is handy for all request handlers which returns lists, - * as the current client does not support deserializing into a parametrized - * {@code List.class}. - * - *

- * Usage: - * - *

{@code @Override
-   * public Result> run() {
-   *   return Result.toList(sendGetRequest("/names", String[].class));
-   * }
-   * }
- */ - public static Result> toList(Response response) { - return toList(response, Function.identity()); - } - - public static Result> toList(Response response, Function mapper) { - List mapped = Optional.ofNullable(response.getBody()) - .map(Arrays::asList).orElse(new ArrayList<>()) - .stream().map(mapper).collect(Collectors.toList()); - return new Result<>(response, mapped); - } - - /** - * Convert {@code T[]} response to a {@code List} response. - * This is handy for all request handlers which returns lists, - * as the current client does not support deserializing into a parametrized - * {@code List.class}. - * - *

- * Usage: - * - *

{@code @Override
-   * public Future> run(FutureCallback> callback) {
-   *   return sendGetRequest("/names", callback, Result.toListParser(String[].class));
-   * }
-   * }
- */ - public static ResponseParser> toListParser(Class cls) { - return new ResponseParser>() { - - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, cls); - return Result.toList(resp); - } - }; - } - - /** - * Convert {@code Result} response to a {@code Result}. - * The result contains true if status code is in 100-299 range. - * - * @param response Response from a call that does not return a value, like - * {@link BaseClient#sendDeleteRequest}. - * @return {@code Result} - */ - public static Result voidToBoolean(Response response) { - int status = response.getStatusCode(); - return new Result<>(status, status <= 299, response.getErrors()); - } - - /** - * Convert {@code Result} response to a {@code Result}. - * The result contains true if status code is in 100-299 range or is one of the - * allowed codes (e.g. HTTP 409 is used when the request has no effect, because - * a previous one has already succeeded). - * - * @param allowCodes Avoid treating these error codes as an error - * and only return false. - * - * @param response Response from a call that does not return a value, like - * {@link BaseClient#sendDeleteRequest}. - * @return {@code Result} - */ - public static Result voidToBoolean(Response response, int... allowCodes) { - Integer status = response.getStatusCode(); - boolean isCodeAllowed = Arrays.stream(allowCodes).anyMatch(status::equals); - if (status <= 299) { - return new Result<>(status, true, null); - } - return new Result<>(status, false, isCodeAllowed ? null : response.getErrors()); - } - - /** - * Get a custom parser to convert {@code Result} response as to a - * {@code Result}. The result contains true if status code is 200. - * - * @return {@code Result} - */ - public static ResponseParser voidToBooleanParser() { - return new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Void.class); - return voidToBoolean(resp); - } - }; - } - - /** - * Get a custom parser to convert {@code Result} response as to a - * {@code Result}. The result contains true if status code is 200. - * - * @param allowCodes Avoid treating these error codes as an error - * and only return false. - * - * @return {@code Result} - */ - public static ResponseParser voidToBooleanParser(int... allowCodes) { - return new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Void.class); - return voidToBoolean(resp, allowCodes); - } - }; - } - - public static ResponseParser> arrayToListParser(Class cls) { - return arrayToListParser(cls, Function.identity()); - } - - public static ResponseParser> arrayToListParser(Class cls, - Function mapper) { - return new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, cls); - List mapped = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList).orElse(new ArrayList<>()) - .stream().map(mapper).collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), mapped, resp.getErrors()); - } - }; - } -} diff --git a/src/main/java/io/weaviate/client/base/Serializer.java b/src/main/java/io/weaviate/client/base/Serializer.java deleted file mode 100644 index 2469d0ef7..000000000 --- a/src/main/java/io/weaviate/client/base/Serializer.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.base; - -import java.lang.reflect.Type; - -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.reflect.TypeToken; - -import io.weaviate.client.base.util.GroupHitDeserializer; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.graphql.model.GraphQLGetBaseObject; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; - -public class Serializer { - private Gson gson; - - public Serializer() { - this.gson = new GsonBuilder() - .disableHtmlEscaping() - .registerTypeAdapter(WeaviateObject.class, WeaviateObject.Adapter.INSTANCE) - .create(); - } - - public GraphQLTypedResponse toGraphQLTypedResponse(String response, Class classOfT) { - Gson gsonTyped = new GsonBuilder() - .disableHtmlEscaping() - .registerTypeAdapter(GraphQLGetBaseObject.Additional.Group.GroupHit.class, new GroupHitDeserializer()) - .create(); - return gsonTyped.fromJson(response, - TypeToken.getParameterized(GraphQLTypedResponse.class, classOfT).getType()); - } - - public C toResponse(String response, Type typeOfT) { - return gson.fromJson(response, typeOfT); - } - - public T toResponse(String response, Class classOfT) { - return gson.fromJson(response, classOfT); - } - - public String toJsonString(Object object) { - return (object != null) ? gson.toJson(object) : null; - } - - public Result toResult(int statusCode, String body, Class classOfT) { - if (statusCode < 399) { - return new Result<>(toResponse(statusCode, body, classOfT)); - } - return new Result<>(statusCode, null, toWeaviateError(body)); - } - - public Response toResponse(int statusCode, String body, Class classOfT) { - if (statusCode < 399) { - T obj = toResponse(body, classOfT); - return new Response<>(statusCode, obj, null); - } - return new Response<>(statusCode, null, toWeaviateError(body)); - } - - public Response> toGraphQLTypedResponse(int statusCode, String body, Class classOfC) { - if (statusCode < 399) { - GraphQLTypedResponse obj = toGraphQLTypedResponse(body, classOfC); - return new Response<>(statusCode, obj, null); - } - return new Response<>(statusCode, null, toWeaviateError(body)); - } - - public Result> toGraphQLTypedResult(int statusCode, String body, Class classOfC) { - if (statusCode < 399) { - return new Result<>(toGraphQLTypedResponse(statusCode, body, classOfC)); - } - return new Result<>(statusCode, null, toWeaviateError(body)); - } - - public WeaviateErrorResponse toWeaviateError(String body) { - return toResponse(body, WeaviateErrorResponse.class); - } -} diff --git a/src/main/java/io/weaviate/client/base/WeaviateError.java b/src/main/java/io/weaviate/client/base/WeaviateError.java deleted file mode 100644 index b05cdb2e6..000000000 --- a/src/main/java/io/weaviate/client/base/WeaviateError.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.base; - -import java.util.List; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class WeaviateError { - int statusCode; - List messages; -} diff --git a/src/main/java/io/weaviate/client/base/WeaviateErrorMessage.java b/src/main/java/io/weaviate/client/base/WeaviateErrorMessage.java deleted file mode 100644 index bcf92bfba..000000000 --- a/src/main/java/io/weaviate/client/base/WeaviateErrorMessage.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.base; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@AllArgsConstructor(access = AccessLevel.PUBLIC) -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class WeaviateErrorMessage { - String message; - transient Throwable throwable; // transient = not serialized by gson. This field is only used on Java. -} diff --git a/src/main/java/io/weaviate/client/base/WeaviateErrorResponse.java b/src/main/java/io/weaviate/client/base/WeaviateErrorResponse.java deleted file mode 100644 index e5fd62c1e..000000000 --- a/src/main/java/io/weaviate/client/base/WeaviateErrorResponse.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.base; - -import java.util.ArrayList; -import java.util.List; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class WeaviateErrorResponse { - Integer code; - String message; - - @Builder.Default - List error = new ArrayList<>(); -} diff --git a/src/main/java/io/weaviate/client/base/grpc/AsyncGrpcClient.java b/src/main/java/io/weaviate/client/base/grpc/AsyncGrpcClient.java deleted file mode 100644 index 5c2636b85..000000000 --- a/src/main/java/io/weaviate/client/base/grpc/AsyncGrpcClient.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.weaviate.client.base.grpc; - -import com.google.common.util.concurrent.ListenableFuture; -import io.grpc.ManagedChannel; -import io.grpc.Metadata; -import io.grpc.stub.MetadataUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.grpc.base.BaseGrpcClient; -import io.weaviate.client.grpc.protocol.v1.WeaviateGrpc; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AccessLevel; -import lombok.experimental.FieldDefaults; - -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class AsyncGrpcClient extends BaseGrpcClient { - WeaviateGrpc.WeaviateFutureStub client; - ManagedChannel channel; - - private AsyncGrpcClient(WeaviateGrpc.WeaviateFutureStub client, ManagedChannel channel) { - this.client = client; - this.channel = channel; - } - - public ListenableFuture batchObjects(WeaviateProtoBatch.BatchObjectsRequest request) { - return this.client.batchObjects(request); - } - - public void shutdown() { - this.channel.shutdown(); - } - - public static AsyncGrpcClient create(Config config, AccessTokenProvider tokenProvider) { - Metadata headers = getHeaders(config, tokenProvider); - ManagedChannel channel = buildChannel(config); - WeaviateGrpc.WeaviateFutureStub stub = WeaviateGrpc.newFutureStub(channel); - WeaviateGrpc.WeaviateFutureStub client = stub.withInterceptors(MetadataUtils.newAttachHeadersInterceptor(headers)); - return new AsyncGrpcClient(client, channel); - } -} diff --git a/src/main/java/io/weaviate/client/base/grpc/GrpcClient.java b/src/main/java/io/weaviate/client/base/grpc/GrpcClient.java deleted file mode 100644 index 003a5136f..000000000 --- a/src/main/java/io/weaviate/client/base/grpc/GrpcClient.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.client.base.grpc; - -import io.grpc.ManagedChannel; -import io.grpc.Metadata; -import io.grpc.stub.MetadataUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.grpc.base.BaseGrpcClient; -import io.weaviate.client.grpc.protocol.v1.WeaviateGrpc; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AccessLevel; -import lombok.experimental.FieldDefaults; - -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class GrpcClient extends BaseGrpcClient { - WeaviateGrpc.WeaviateBlockingStub client; - ManagedChannel channel; - - private GrpcClient(WeaviateGrpc.WeaviateBlockingStub client, ManagedChannel channel) { - this.client = client; - this.channel = channel; - } - - public WeaviateProtoBatch.BatchObjectsReply batchObjects(WeaviateProtoBatch.BatchObjectsRequest request) { - return this.client.batchObjects(request); - } - - public WeaviateProtoSearchGet.SearchReply search(WeaviateProtoSearchGet.SearchRequest request) { - return this.client.search(request); - } - - public void shutdown() { - this.channel.shutdown(); - } - - public static GrpcClient create(Config config, AccessTokenProvider tokenProvider) { - Metadata headers = getHeaders(config, tokenProvider); - ManagedChannel channel = buildChannel(config); - WeaviateGrpc.WeaviateBlockingStub blockingStub = WeaviateGrpc.newBlockingStub(channel); - WeaviateGrpc.WeaviateBlockingStub client = blockingStub - .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(headers)); - return new GrpcClient(client, channel); - } -} diff --git a/src/main/java/io/weaviate/client/base/grpc/base/BaseGrpcClient.java b/src/main/java/io/weaviate/client/base/grpc/base/BaseGrpcClient.java deleted file mode 100644 index b659711b6..000000000 --- a/src/main/java/io/weaviate/client/base/grpc/base/BaseGrpcClient.java +++ /dev/null @@ -1,48 +0,0 @@ -package io.weaviate.client.base.grpc.base; - -import io.grpc.ManagedChannel; -import io.grpc.ManagedChannelBuilder; -import io.grpc.Metadata; -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.Map; - -public class BaseGrpcClient { - - protected static Metadata getHeaders(Config config, AccessTokenProvider tokenProvider) { - Metadata headers = new Metadata(); - if (config.getHeaders() != null) { - for (Map.Entry e : config.getHeaders().entrySet()) { - headers.put(Metadata.Key.of(e.getKey(), Metadata.ASCII_STRING_MARSHALLER), e.getValue()); - } - } - if (tokenProvider != null) { - headers.put(Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER), String.format("Bearer %s", tokenProvider.getAccessToken())); - } - return headers; - } - - protected static ManagedChannel buildChannel(Config config) { - ManagedChannelBuilder channelBuilder = ManagedChannelBuilder.forTarget(getAddress(config)); - if (config.isGRPCSecured()) { - channelBuilder = channelBuilder.useTransportSecurity(); - } else { - channelBuilder.usePlaintext(); - } - return channelBuilder.build(); - } - - private static String getAddress(Config config) { - if (config.getGRPCHost() != null) { - String host = config.getGRPCHost(); - if (host.contains(":")) { - return host; - } - if (config.isGRPCSecured()) { - return String.format("%s:443", host); - } - return String.format("%s:80", host); - } - return ""; - } -} diff --git a/src/main/java/io/weaviate/client/base/http/HttpClient.java b/src/main/java/io/weaviate/client/base/http/HttpClient.java deleted file mode 100644 index 38d5561da..000000000 --- a/src/main/java/io/weaviate/client/base/http/HttpClient.java +++ /dev/null @@ -1,10 +0,0 @@ -package io.weaviate.client.base.http; - -public interface HttpClient { - HttpResponse sendGetRequest(String url) throws Exception; - HttpResponse sendPostRequest(String url, String json) throws Exception; - HttpResponse sendPutRequest(String url, String json) throws Exception; - HttpResponse sendPatchRequest(String url, String json) throws Exception; - HttpResponse sendDeleteRequest(String url, String json) throws Exception; - HttpResponse sendHeadRequest(String url) throws Exception; -} diff --git a/src/main/java/io/weaviate/client/base/http/HttpResponse.java b/src/main/java/io/weaviate/client/base/http/HttpResponse.java deleted file mode 100644 index 09afe4e15..000000000 --- a/src/main/java/io/weaviate/client/base/http/HttpResponse.java +++ /dev/null @@ -1,14 +0,0 @@ -package io.weaviate.client.base.http; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class HttpResponse { - int statusCode; - String body; -} diff --git a/src/main/java/io/weaviate/client/base/http/async/AsyncHttpClient.java b/src/main/java/io/weaviate/client/base/http/async/AsyncHttpClient.java deleted file mode 100644 index 01392b479..000000000 --- a/src/main/java/io/weaviate/client/base/http/async/AsyncHttpClient.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.base.http.async; - -import io.weaviate.client.Config; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.client5.http.impl.async.HttpAsyncClients; -import org.apache.hc.core5.reactor.IOReactorConfig; -import org.apache.hc.core5.util.Timeout; - -public class AsyncHttpClient { - - public static CloseableHttpAsyncClient create(Config config) { - IOReactorConfig ioReactorConfig = IOReactorConfig.custom() - .setSoTimeout(Timeout.ofSeconds(config.getSocketTimeout())) - .build(); - - return HttpAsyncClients.custom() - .setIOReactorConfig(ioReactorConfig) - .build(); - } -} diff --git a/src/main/java/io/weaviate/client/base/http/async/ResponseParser.java b/src/main/java/io/weaviate/client/base/http/async/ResponseParser.java deleted file mode 100644 index 878da54c3..000000000 --- a/src/main/java/io/weaviate/client/base/http/async/ResponseParser.java +++ /dev/null @@ -1,16 +0,0 @@ -package io.weaviate.client.base.http.async; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public abstract class ResponseParser { - protected final Serializer serializer; - - public ResponseParser() { - this.serializer = new Serializer(); - } - - public abstract Result parse(HttpResponse response, String body, ContentType contentType); -} diff --git a/src/main/java/io/weaviate/client/base/http/async/WeaviateGraphQLTypedResponseConsumer.java b/src/main/java/io/weaviate/client/base/http/async/WeaviateGraphQLTypedResponseConsumer.java deleted file mode 100644 index 5de7a8f28..000000000 --- a/src/main/java/io/weaviate/client/base/http/async/WeaviateGraphQLTypedResponseConsumer.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.base.http.async; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpException; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.nio.entity.BasicAsyncEntityConsumer; -import org.apache.hc.core5.http.nio.support.AbstractAsyncResponseConsumer; -import org.apache.hc.core5.http.protocol.HttpContext; - -public class WeaviateGraphQLTypedResponseConsumer extends AbstractAsyncResponseConsumer>, byte[]> { - private final Serializer serializer; - private final Class classOfT; - - public WeaviateGraphQLTypedResponseConsumer(Class classOfT) { - super(new BasicAsyncEntityConsumer()); - this.serializer = new Serializer(); - this.classOfT = classOfT; - } - - @Override - protected Result> buildResult(HttpResponse response, byte[] entity, ContentType contentType) { - String body = (entity != null) ? new String(entity, StandardCharsets.UTF_8) : ""; - return serializer.toGraphQLTypedResult(response.getCode(), body, classOfT); - } - - @Override - public void informationResponse(HttpResponse response, HttpContext context) throws HttpException, IOException { - } -} diff --git a/src/main/java/io/weaviate/client/base/http/async/WeaviateResponseConsumer.java b/src/main/java/io/weaviate/client/base/http/async/WeaviateResponseConsumer.java deleted file mode 100644 index 652c8682c..000000000 --- a/src/main/java/io/weaviate/client/base/http/async/WeaviateResponseConsumer.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.base.http.async; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpException; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.nio.entity.BasicAsyncEntityConsumer; -import org.apache.hc.core5.http.nio.support.AbstractAsyncResponseConsumer; -import org.apache.hc.core5.http.protocol.HttpContext; - -public class WeaviateResponseConsumer extends AbstractAsyncResponseConsumer, byte[]> { - private final Serializer serializer; - private final Class classOfT; - private final ResponseParser parser; - - public WeaviateResponseConsumer(Class classOfT, ResponseParser parser) { - super(new BasicAsyncEntityConsumer()); - this.serializer = new Serializer(); - this.classOfT = classOfT; - this.parser = parser; - } - - @Override - protected Result buildResult(HttpResponse response, byte[] entity, ContentType contentType) { - String body = (entity != null) ? new String(entity, StandardCharsets.UTF_8) : ""; - if (this.parser != null) { - return this.parser.parse(response, body, contentType); - } - return serializer.toResult(response.getCode(), body, classOfT); - } - - @Override - public void informationResponse(HttpResponse response, HttpContext context) throws HttpException, IOException { - } -} diff --git a/src/main/java/io/weaviate/client/base/http/builder/HttpApacheClientBuilder.java b/src/main/java/io/weaviate/client/base/http/builder/HttpApacheClientBuilder.java deleted file mode 100644 index 377982717..000000000 --- a/src/main/java/io/weaviate/client/base/http/builder/HttpApacheClientBuilder.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.base.http.builder; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.impl.CommonsHttpClientImpl; -import java.util.concurrent.TimeUnit; -import org.apache.hc.client5.http.config.RequestConfig; -import org.apache.hc.client5.http.impl.classic.HttpClientBuilder; -import org.apache.hc.core5.http.HttpHost; -import org.apache.hc.core5.util.Timeout; - -public class HttpApacheClientBuilder { - - private HttpApacheClientBuilder() {} - - public static CommonsHttpClientImpl.CloseableHttpClientBuilder build(Config config) { - RequestConfig.Builder requestConfigBuilder = RequestConfig.custom() - .setConnectTimeout(Timeout.of(config.getConnectionTimeout(), TimeUnit.SECONDS)) - .setConnectionRequestTimeout(Timeout.of(config.getConnectionRequestTimeout(), TimeUnit.SECONDS)) - .setResponseTimeout(Timeout.of(config.getSocketTimeout(), TimeUnit.SECONDS)); - - if (config.getProxyHost() != null) { - requestConfigBuilder.setProxy(new HttpHost(config.getProxyScheme(), config.getProxyHost(), config.getProxyPort())); - } - - RequestConfig requestConfig = requestConfigBuilder.build(); - return HttpClientBuilder.create().setDefaultRequestConfig(requestConfig)::build; - } -} diff --git a/src/main/java/io/weaviate/client/base/http/impl/CommonsHttpClientImpl.java b/src/main/java/io/weaviate/client/base/http/impl/CommonsHttpClientImpl.java deleted file mode 100644 index 957bb5e2b..000000000 --- a/src/main/java/io/weaviate/client/base/http/impl/CommonsHttpClientImpl.java +++ /dev/null @@ -1,126 +0,0 @@ -package io.weaviate.client.base.http.impl; - -import java.io.Closeable; -import java.io.IOException; -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.util.Map; - -import org.apache.hc.client5.http.classic.methods.HttpDelete; -import org.apache.hc.client5.http.classic.methods.HttpGet; -import org.apache.hc.client5.http.classic.methods.HttpHead; -import org.apache.hc.client5.http.classic.methods.HttpPatch; -import org.apache.hc.client5.http.classic.methods.HttpPost; -import org.apache.hc.client5.http.classic.methods.HttpPut; -import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase; -import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; -import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse; -import org.apache.hc.core5.http.HttpHeaders; -import org.apache.hc.core5.http.io.entity.EntityUtils; -import org.apache.hc.core5.http.io.entity.StringEntity; -import org.apache.hc.core5.http.message.BasicClassicHttpRequest; - -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.http.HttpResponse; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class CommonsHttpClientImpl implements HttpClient, Closeable { - private final Map headers; - private AccessTokenProvider tokenProvider; - private final CloseableHttpClientBuilder clientBuilder; - - public CommonsHttpClientImpl(Map headers, CloseableHttpClientBuilder clientBuilder) { - this(headers, null, clientBuilder); - } - - public CommonsHttpClientImpl(Map headers, AccessTokenProvider tokenProvider, - CloseableHttpClientBuilder clientBuilder) { - this.headers = headers; - this.clientBuilder = clientBuilder; - this.tokenProvider = tokenProvider; - } - - @Override - public HttpResponse sendGetRequest(String url) throws Exception { - return sendRequestWithoutPayload(new HttpGet(url)); - } - - @Override - public HttpResponse sendPostRequest(String url, String json) throws Exception { - if (json == null) { - return sendRequestWithoutPayload(new HttpPost(url)); - } - return sendRequestWithPayload(new HttpPost(url), json); - } - - @Override - public HttpResponse sendPutRequest(String url, String json) throws Exception { - return sendRequestWithPayload(new HttpPut(url), json); - } - - @Override - public HttpResponse sendPatchRequest(String url, String json) throws Exception { - return sendRequestWithPayload(new HttpPatch(url), json); - } - - @Override - public HttpResponse sendDeleteRequest(String url, String json) throws Exception { - if (json == null) { - return sendRequestWithoutPayload(new HttpDelete(url)); - } - return sendRequestWithPayload(new HttpDeleteWithBody(url), json); - } - - @Override - public HttpResponse sendHeadRequest(String url) throws Exception { - return sendRequestWithoutPayload(new HttpHead(url)); - } - - private HttpResponse sendRequestWithoutPayload(BasicClassicHttpRequest request) throws Exception { - request.setHeader(HttpHeaders.ACCEPT, "*/*"); - return sendRequest(request); - } - - private HttpResponse sendRequestWithPayload(BasicClassicHttpRequest request, String jsonString) throws Exception { - request.setHeader(HttpHeaders.ACCEPT, "application/json"); - request.setHeader(HttpHeaders.CONTENT_TYPE, "application/json"); - request.setEntity(new StringEntity(jsonString, StandardCharsets.UTF_8)); - return sendRequest(request); - } - - private HttpResponse sendRequest(BasicClassicHttpRequest request) throws Exception { - if (headers != null && headers.size() > 0) { - headers.forEach(request::addHeader); - } - if (tokenProvider != null) { - request.addHeader("Authorization", String.format("Bearer %s", tokenProvider.getAccessToken())); - } - - CloseableHttpClient client = clientBuilder.build(); - CloseableHttpResponse response = client.execute(request); - - int statusCode = response.getCode(); - String body = response.getEntity() != null - ? EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8) - : ""; - client.close(); - return new HttpResponse(statusCode, body); - } - - @Override - public void close() throws IOException { - if (tokenProvider != null) { - tokenProvider.shutdown(); - } - } - - private static class HttpDeleteWithBody extends HttpUriRequestBase { - public HttpDeleteWithBody(String url) { - super(HttpDelete.METHOD_NAME, URI.create(url)); - } - } - - public interface CloseableHttpClientBuilder { - CloseableHttpClient build(); - } -} diff --git a/src/main/java/io/weaviate/client/base/util/Assert.java b/src/main/java/io/weaviate/client/base/util/Assert.java deleted file mode 100644 index ff0955495..000000000 --- a/src/main/java/io/weaviate/client/base/util/Assert.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.base.util; - -import java.util.Objects; - -public class Assert { - - private Assert(){} - - public static void requireGreater(int value, int minValue, String paramName) { - if (value <= minValue) { - throw new IllegalArgumentException(String.format("%s should be greater than %d", paramName, minValue)); - } - } - - public static void requireGreaterEqual(int value, int minValue, String paramName) { - if (value < minValue) { - throw new IllegalArgumentException(String.format("%s should be greater than or equal %d", paramName, minValue)); - } - } - - public static void requiredNotNull(Object value, String paramName) { - if (Objects.isNull(value)) { - throw new IllegalArgumentException(String.format("%s should not be null", paramName)); - } - } -} diff --git a/src/main/java/io/weaviate/client/base/util/BeaconPath.java b/src/main/java/io/weaviate/client/base/util/BeaconPath.java deleted file mode 100644 index b2bfe3b3e..000000000 --- a/src/main/java/io/weaviate/client/base/util/BeaconPath.java +++ /dev/null @@ -1,82 +0,0 @@ -package io.weaviate.client.base.util; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; - -import java.util.Arrays; -import java.util.Objects; -import java.util.function.BiConsumer; - -public class BeaconPath { - - private final DbVersionSupport support; - - public BeaconPath(DbVersionSupport support) { - this.support = support; - } - - public String buildBatchFrom(Params pathParams) { - return build(pathParams, this::addClassName, this::addId, this::addProperty); - } - - public String buildBatchTo(Params pathParams) { - return build(pathParams, this::addClassNameDeprecatedNotSupportedCheck, this::addId); - } - - public String buildSingle(Params pathParams) { - return build(pathParams, this::addClassNameDeprecatedNotSupportedCheck, this::addId); - } - - @SafeVarargs - private final String build(Params pathParams, BiConsumer... modifiers) { - Objects.requireNonNull(pathParams); - - StringBuilder path = new StringBuilder("weaviate://localhost"); - Arrays.stream(modifiers).forEach(consumer -> consumer.accept(path, pathParams)); - return path.toString(); - } - - private void addClassNameDeprecatedNotSupportedCheck(StringBuilder path, Params pathParams) { - if (support.supportsClassNameNamespacedEndpoints()) { - if (StringUtils.isNotBlank(pathParams.className)) { - path.append("/").append(StringUtils.trim(pathParams.className)); - } else { - support.warnDeprecatedNonClassNameNamespacedEndpointsForBeacons(); - } - } else if (StringUtils.isNotBlank(pathParams.className)) { - support.warnNotSupportedClassNamespacedEndpointsForBeacons(); - } - } - - private void addClassName(StringBuilder path, Params pathParams) { - if (StringUtils.isNotBlank(pathParams.className)) { - path.append("/").append(StringUtils.trim(pathParams.className)); - } - } - - private void addId(StringBuilder path, Params pathParams) { - if (StringUtils.isNotBlank(pathParams.id)) { - path.append("/").append(StringUtils.trim(pathParams.id)); - } - } - - private void addProperty(StringBuilder path, Params pathParams) { - if (StringUtils.isNotBlank(pathParams.property)) { - path.append("/").append(StringUtils.trim(pathParams.property)); - } - } - - - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Params { - - String id; - String className; - String property; - } -} diff --git a/src/main/java/io/weaviate/client/base/util/CrossReference.java b/src/main/java/io/weaviate/client/base/util/CrossReference.java deleted file mode 100644 index f0f33f131..000000000 --- a/src/main/java/io/weaviate/client/base/util/CrossReference.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.base.util; - -import lombok.AccessLevel; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; - -@ToString -@Getter -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class CrossReference { - String peerName; - String className; - String targetID; - boolean local; - - public CrossReference(String peerName, String className, String targetID) { - this.local = peerName != null && peerName.equals("localhost"); - this.peerName = peerName; - this.className = className; - this.targetID = targetID; - } - - public static CrossReference fromBeacon(String beacon) { - if (StringUtils.isNotBlank(beacon) && beacon.startsWith("weaviate://")) { - String path = beacon.replaceFirst("weaviate://", ""); - String[] parts = path.split("/"); - if (parts.length == 3) { - return new CrossReference(parts[0], parts[1], parts[2]); - } - if (parts.length == 2) { - return new CrossReference(parts[0], "", parts[1]); - } - } - return null; - } -} diff --git a/src/main/java/io/weaviate/client/base/util/DbVersionProvider.java b/src/main/java/io/weaviate/client/base/util/DbVersionProvider.java deleted file mode 100644 index a012afbdf..000000000 --- a/src/main/java/io/weaviate/client/base/util/DbVersionProvider.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.base.util; - -import java.util.Optional; - -public class DbVersionProvider { - - private static final String EMPTY_VERSION = ""; - - private final VersionGetter getter; - private String version; - - - public DbVersionProvider(VersionGetter getter) { - this.getter = getter; - this.version = EMPTY_VERSION; - } - - - public String getVersion() { - refresh(); - return version; - } - - public void refresh() { - refresh(false); - } - - public void refresh(boolean force) { - if (force || EMPTY_VERSION.equals(version)) { - this.version = getter.get().orElse(EMPTY_VERSION); - } - } - - - public interface VersionGetter { - Optional get(); - } -} diff --git a/src/main/java/io/weaviate/client/base/util/DbVersionSupport.java b/src/main/java/io/weaviate/client/base/util/DbVersionSupport.java deleted file mode 100644 index fa2ff66cc..000000000 --- a/src/main/java/io/weaviate/client/base/util/DbVersionSupport.java +++ /dev/null @@ -1,63 +0,0 @@ -package io.weaviate.client.base.util; - -import lombok.RequiredArgsConstructor; -import org.apache.commons.lang3.StringUtils; - -@RequiredArgsConstructor -public class DbVersionSupport { - - private final DbVersionProvider provider; - - // supported since 1.14 - public boolean supportsClassNameNamespacedEndpoints() { - return satisfiesVersion(1, 14); - } - - public boolean supportsOnly100TenantsInOneRequest() { - return satisfiesVersion(1, 26); - } - - private boolean satisfiesVersion(int major, int minor) { - String[] versionNumbers = StringUtils.split(provider.getVersion(), "."); - if (versionNumbers != null && versionNumbers.length >= 2) { - int parsedMajor = Integer.parseInt(versionNumbers[0]); - int parsedMinor = Integer.parseInt(versionNumbers[1]); - return (parsedMajor == major && parsedMinor >= minor) || parsedMajor >= 2; - } - return false; - } - - public void warnDeprecatedNonClassNameNamespacedEndpointsForObjects() { - System.err.printf("WARNING: Usage of objects paths without className is deprecated in Weaviate %s." + - " Please provide className parameter\n", provider.getVersion()); - } - - public void warnDeprecatedNonClassNameNamespacedEndpointsForReferences() { - System.err.printf("WARNING: Usage of references paths without className is deprecated in Weaviate %s." + - " Please provide className parameter\n", provider.getVersion()); - } - - public void warnDeprecatedNonClassNameNamespacedEndpointsForBeacons() { - System.err.printf("WARNING: Usage of beacon paths without className is deprecated in Weaviate %s." + - " Please provide className parameter\n", provider.getVersion()); - } - - public void warnNotSupportedClassNamespacedEndpointsForObjects() { - System.err.printf("WARNING: Usage of objects paths with className is not supported in Weaviate %s." + - " className parameter is ignored\n", provider.getVersion()); - } - public void warnNotSupportedClassParameterInEndpointsForObjects() { - System.err.printf("WARNING: Usage of objects paths with class query parameter is not supported in Weaviate %s." + - " class query parameter is ignored\n", provider.getVersion()); - } - - public void warnNotSupportedClassNamespacedEndpointsForReferences() { - System.err.printf("WARNING: Usage of references paths with className is not supported in Weaviate %s." + - " className parameter is ignored\n", provider.getVersion()); - } - - public void warnNotSupportedClassNamespacedEndpointsForBeacons() { - System.err.printf("WARNING: Usage of beacons paths with className is not supported in Weaviate %s." + - " className parameter is ignored\n", provider.getVersion()); - } -} diff --git a/src/main/java/io/weaviate/client/base/util/Futures.java b/src/main/java/io/weaviate/client/base/util/Futures.java deleted file mode 100644 index 428061929..000000000 --- a/src/main/java/io/weaviate/client/base/util/Futures.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.client.base.util; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Executor; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import java.util.function.BiFunction; -import java.util.function.Function; -import java.util.function.Supplier; - -public class Futures { - - private Futures() { - } - - public static CompletableFuture supplyDelayed(Supplier> supplier, long millis, - Executor executor) throws InterruptedException { - if (executor instanceof ScheduledExecutorService) { - return CompletableFuture.supplyAsync( - supplier, - command -> ((ScheduledExecutorService) executor).schedule(command, millis, TimeUnit.MILLISECONDS) - ).thenCompose(f -> f); - } - Thread.sleep(millis); - return supplier.get(); - } - - public static CompletableFuture thenComposeAsync(CompletableFuture future, Function> callback, - Executor executor) { - if (executor != null) { - return future.thenComposeAsync(callback, executor); - } - return future.thenComposeAsync(callback); - } - - public static CompletableFuture handleAsync(CompletableFuture future, BiFunction> callback, - Executor executor) { - if (executor != null) { - return future.handleAsync(callback, executor).thenCompose(f -> f); - } - return future.handleAsync(callback).thenCompose(f -> f); - } - - public static CompletableFuture supplyAsync(Supplier supplier, Executor executor) { - if (executor != null) { - return CompletableFuture.supplyAsync(supplier, executor); - } - return CompletableFuture.supplyAsync(supplier); - } -} diff --git a/src/main/java/io/weaviate/client/base/util/GroupHitDeserializer.java b/src/main/java/io/weaviate/client/base/util/GroupHitDeserializer.java deleted file mode 100644 index 270bef842..000000000 --- a/src/main/java/io/weaviate/client/base/util/GroupHitDeserializer.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.base.util; - -import com.google.gson.JsonDeserializationContext; -import com.google.gson.JsonDeserializer; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParseException; -import com.google.gson.reflect.TypeToken; -import io.weaviate.client.v1.graphql.model.GraphQLGetBaseObject; -import java.lang.reflect.Type; -import java.util.Map; - -public class GroupHitDeserializer implements JsonDeserializer { - - @Override - public GraphQLGetBaseObject.Additional.Group.GroupHit deserialize(JsonElement json, Type typeOfT, - JsonDeserializationContext context) throws JsonParseException { - JsonObject jsonObject = json.getAsJsonObject(); - - GraphQLGetBaseObject.Additional.Group.GroupHit.AdditionalGroupHit additional = - context.deserialize(jsonObject.get("_additional"), GraphQLGetBaseObject.Additional.Group.GroupHit.AdditionalGroupHit.class); - - // Remove _additional from the JSON object - jsonObject.remove("_additional"); - - // Deserialize the rest into a Map - Type mapType = new TypeToken>() {}.getType(); - Map properties = context.deserialize(jsonObject, mapType); - - return new GraphQLGetBaseObject.Additional.Group.GroupHit(properties, additional); - } -} diff --git a/src/main/java/io/weaviate/client/base/util/GrpcVersionSupport.java b/src/main/java/io/weaviate/client/base/util/GrpcVersionSupport.java deleted file mode 100644 index 2deb930f0..000000000 --- a/src/main/java/io/weaviate/client/base/util/GrpcVersionSupport.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.base.util; - -import lombok.RequiredArgsConstructor; -import org.apache.commons.lang3.StringUtils; - -@RequiredArgsConstructor -public class GrpcVersionSupport { - - private final DbVersionProvider provider; - - public boolean supportsVectorBytesField() { - String[] versionNumbers = StringUtils.split(provider.getVersion(), "."); - if (versionNumbers != null && versionNumbers.length >= 2) { - int major = Integer.parseInt(versionNumbers[0]); - int minor = Integer.parseInt(versionNumbers[1]); - if (major == 1 && minor == 22 && versionNumbers.length == 3) { - String patch = versionNumbers[2]; - if (!patch.contains("rc") && Integer.parseInt(patch) >= 6) { - return true; - } - } - return (major == 1 && minor >= 23) || major >= 2; - } - return false; - } -} diff --git a/src/main/java/io/weaviate/client/base/util/TriConsumer.java b/src/main/java/io/weaviate/client/base/util/TriConsumer.java deleted file mode 100644 index 4a38d12fa..000000000 --- a/src/main/java/io/weaviate/client/base/util/TriConsumer.java +++ /dev/null @@ -1,14 +0,0 @@ -package io.weaviate.client.base.util; - -@FunctionalInterface -public interface TriConsumer { - - /** - * Performs this operation on the given arguments. - * - * @param t the first input argument - * @param u the second input argument - * @param v the third input argument - */ - void accept(T t, U u, V v); -} diff --git a/src/main/java/io/weaviate/client/base/util/UrlEncoder.java b/src/main/java/io/weaviate/client/base/util/UrlEncoder.java deleted file mode 100644 index 88c877774..000000000 --- a/src/main/java/io/weaviate/client/base/util/UrlEncoder.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.base.util; - -import org.apache.commons.lang3.StringUtils; - -import java.io.UnsupportedEncodingException; -import java.net.URLEncoder; -import java.nio.charset.StandardCharsets; - -public class UrlEncoder { - - private UrlEncoder() {} - - public static String encodeQueryParam(String key, String value) { - return String.format("%s=%s", encode(StringUtils.trim(key)), encode(StringUtils.trim(value))); - } - - public static String encodePathParam(String value) { - return encode(StringUtils.trim(value)); - } - - public static String encode(String value) { - try { - return URLEncoder.encode(value, StandardCharsets.UTF_8.toString()); - } catch (UnsupportedEncodingException e) { - return value; - } - } -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateGrpc.java b/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateGrpc.java deleted file mode 100644 index 5ccc84efe..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateGrpc.java +++ /dev/null @@ -1,367 +0,0 @@ -package io.weaviate.client.grpc.protocol.v0; - -import static io.grpc.MethodDescriptor.generateFullMethodName; - -/** - */ -@javax.annotation.Generated( - value = "by gRPC proto compiler (version 1.58.0)", - comments = "Source: v0/weaviate.proto") -@io.grpc.stub.annotations.GrpcGenerated -public final class WeaviateGrpc { - - private WeaviateGrpc() {} - - public static final java.lang.String SERVICE_NAME = "weaviategrpc.Weaviate"; - - // Static method descriptors that strictly reflect the proto. - private static volatile io.grpc.MethodDescriptor getSearchMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "Search", - requestType = io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.class, - responseType = io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getSearchMethod() { - io.grpc.MethodDescriptor getSearchMethod; - if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { - WeaviateGrpc.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( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("Search")) - .build(); - } - } - } - return getSearchMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchObjectsMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchObjects", - requestType = io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.class, - responseType = io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getBatchObjectsMethod() { - io.grpc.MethodDescriptor getBatchObjectsMethod; - if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { - WeaviateGrpc.getBatchObjectsMethod = getBatchObjectsMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchObjects")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchObjects")) - .build(); - } - } - } - return getBatchObjectsMethod; - } - - /** - * Creates a new async stub that supports all call types for the service - */ - public static WeaviateStub newStub(io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateStub(channel, callOptions); - } - }; - return WeaviateStub.newStub(factory, channel); - } - - /** - * Creates a new blocking-style stub that supports unary and streaming output calls on the service - */ - public static WeaviateBlockingStub newBlockingStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateBlockingStub(channel, callOptions); - } - }; - return WeaviateBlockingStub.newStub(factory, channel); - } - - /** - * Creates a new ListenableFuture-style stub that supports unary calls on the service - */ - public static WeaviateFutureStub newFutureStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateFutureStub(channel, callOptions); - } - }; - return WeaviateFutureStub.newStub(factory, channel); - } - - /** - */ - public interface AsyncService { - - /** - */ - default void search(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSearchMethod(), responseObserver); - } - - /** - */ - default void batchObjects(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchObjectsMethod(), responseObserver); - } - } - - /** - * Base class for the server implementation of the service Weaviate. - */ - public static abstract class WeaviateImplBase - implements io.grpc.BindableService, AsyncService { - - @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { - return WeaviateGrpc.bindService(this); - } - } - - /** - * A stub to allow clients to do asynchronous rpc calls to service Weaviate. - */ - public static final class WeaviateStub - extends io.grpc.stub.AbstractAsyncStub { - private WeaviateStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateStub(channel, callOptions); - } - - /** - */ - public void search(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getSearchMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchObjects(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request, responseObserver); - } - } - - /** - * A stub to allow clients to do synchronous rpc calls to service Weaviate. - */ - public static final class WeaviateBlockingStub - extends io.grpc.stub.AbstractBlockingStub { - private WeaviateBlockingStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateBlockingStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateBlockingStub(channel, callOptions); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply search(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getSearchMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply batchObjects(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getBatchObjectsMethod(), getCallOptions(), request); - } - } - - /** - * A stub to allow clients to do ListenableFuture-style rpc calls to service Weaviate. - */ - public static final class WeaviateFutureStub - extends io.grpc.stub.AbstractFutureStub { - private WeaviateFutureStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateFutureStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateFutureStub(channel, callOptions); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture search( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getSearchMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture batchObjects( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request); - } - } - - private static final int METHODID_SEARCH = 0; - private static final int METHODID_BATCH_OBJECTS = 1; - - 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 AsyncService serviceImpl; - private final int methodId; - - MethodHandlers(AsyncService 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_SEARCH: - serviceImpl.search((io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_OBJECTS: - serviceImpl.batchObjects((io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest) 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(); - } - } - } - - public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { - return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) - .addMethod( - getSearchMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest, - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply>( - service, METHODID_SEARCH))) - .addMethod( - getBatchObjectsMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest, - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply>( - service, METHODID_BATCH_OBJECTS))) - .build(); - } - - private static abstract class WeaviateBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { - WeaviateBaseDescriptorSupplier() {} - - @java.lang.Override - public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProto.getDescriptor(); - } - - @java.lang.Override - public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { - return getFileDescriptor().findServiceByName("Weaviate"); - } - } - - private static final class WeaviateFileDescriptorSupplier - extends WeaviateBaseDescriptorSupplier { - WeaviateFileDescriptorSupplier() {} - } - - private static final class WeaviateMethodDescriptorSupplier - extends WeaviateBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { - private final java.lang.String methodName; - - WeaviateMethodDescriptorSupplier(java.lang.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 (WeaviateGrpc.class) { - result = serviceDescriptor; - if (result == null) { - serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) - .setSchemaDescriptor(new WeaviateFileDescriptorSupplier()) - .addMethod(getSearchMethod()) - .addMethod(getBatchObjectsMethod()) - .build(); - } - } - } - return result; - } -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProto.java b/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProto.java deleted file mode 100644 index d33db59df..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProto.java +++ /dev/null @@ -1,47 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v0/weaviate.proto - -package io.weaviate.client.grpc.protocol.v0; - -public final class WeaviateProto { - private WeaviateProto() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\021v0/weaviate.proto\022\014weaviategrpc\032\016v0/ba" + - "tch.proto\032\023v0/search_get.proto2\244\001\n\010Weavi" + - "ate\022B\n\006Search\022\033.weaviategrpc.SearchReque" + - "st\032\031.weaviategrpc.SearchReply\"\000\022T\n\014Batch" + - "Objects\022!.weaviategrpc.BatchObjectsReque" + - "st\032\037.weaviategrpc.BatchObjectsReply\"\000Bj\n" + - "#io.weaviate.client.grpc.protocol.v0B\rWe" + - "aviateProtoZ4github.com/weaviate/weaviat" + - "e/grpc/generated;protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.getDescriptor(), - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.getDescriptor(), - }); - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.getDescriptor(); - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.getDescriptor(); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoBatch.java b/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoBatch.java deleted file mode 100644 index e3e1db997..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoBatch.java +++ /dev/null @@ -1,855 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v0/batch.proto - -package io.weaviate.client.grpc.protocol.v0; - -public final class WeaviateProtoBatch { - private WeaviateProtoBatch() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - public interface BatchObjectsRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviategrpc.BatchObjectsRequest) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviategrpc.BatchObjectsRequest} - */ - public static final class BatchObjectsRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviategrpc.BatchObjectsRequest) - BatchObjectsRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchObjectsRequest.newBuilder() to construct. - private BatchObjectsRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchObjectsRequest() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchObjectsRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest other = (io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviategrpc.BatchObjectsRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviategrpc.BatchObjectsRequest) - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest build() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest buildPartial() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest result = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest other) { - if (other == io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviategrpc.BatchObjectsRequest) - } - - // @@protoc_insertion_point(class_scope:weaviategrpc.BatchObjectsRequest) - private static final io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest(); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchObjectsRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchObjectsReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviategrpc.BatchObjectsReply) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviategrpc.BatchObjectsReply} - */ - public static final class BatchObjectsReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviategrpc.BatchObjectsReply) - BatchObjectsReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchObjectsReply.newBuilder() to construct. - private BatchObjectsReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchObjectsReply() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchObjectsReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply other = (io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviategrpc.BatchObjectsReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviategrpc.BatchObjectsReply) - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.internal_static_weaviategrpc_BatchObjectsReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply build() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply buildPartial() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply result = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply other) { - if (other == io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviategrpc.BatchObjectsReply) - } - - // @@protoc_insertion_point(class_scope:weaviategrpc.BatchObjectsReply) - private static final io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply(); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchObjectsReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviategrpc_BatchObjectsRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviategrpc_BatchObjectsRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviategrpc_BatchObjectsReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviategrpc_BatchObjectsReply_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\016v0/batch.proto\022\014weaviategrpc\"\025\n\023BatchO" + - "bjectsRequest\"\023\n\021BatchObjectsReplyBo\n#io" + - ".weaviate.client.grpc.protocol.v0B\022Weavi" + - "ateProtoBatchZ4github.com/weaviate/weavi" + - "ate/grpc/generated;protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - }); - internal_static_weaviategrpc_BatchObjectsRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviategrpc_BatchObjectsRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviategrpc_BatchObjectsRequest_descriptor, - new java.lang.String[] { }); - internal_static_weaviategrpc_BatchObjectsReply_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviategrpc_BatchObjectsReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviategrpc_BatchObjectsReply_descriptor, - new java.lang.String[] { }); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoSearchGet.java b/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoSearchGet.java deleted file mode 100644 index 4cb2a4fed..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v0/WeaviateProtoSearchGet.java +++ /dev/null @@ -1,855 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v0/search_get.proto - -package io.weaviate.client.grpc.protocol.v0; - -public final class WeaviateProtoSearchGet { - private WeaviateProtoSearchGet() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - public interface SearchRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviategrpc.SearchRequest) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviategrpc.SearchRequest} - */ - public static final class SearchRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviategrpc.SearchRequest) - SearchRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use SearchRequest.newBuilder() to construct. - private SearchRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SearchRequest() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SearchRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest other = (io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviategrpc.SearchRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviategrpc.SearchRequest) - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest build() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest buildPartial() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest result = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest other) { - if (other == io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviategrpc.SearchRequest) - } - - // @@protoc_insertion_point(class_scope:weaviategrpc.SearchRequest) - private static final io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest(); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SearchRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface SearchReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviategrpc.SearchReply) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviategrpc.SearchReply} - */ - public static final class SearchReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviategrpc.SearchReply) - SearchReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use SearchReply.newBuilder() to construct. - private SearchReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SearchReply() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SearchReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply other = (io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviategrpc.SearchReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviategrpc.SearchReply) - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.internal_static_weaviategrpc_SearchReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply build() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply buildPartial() { - io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply result = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply other) { - if (other == io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviategrpc.SearchReply) - } - - // @@protoc_insertion_point(class_scope:weaviategrpc.SearchReply) - private static final io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply(); - } - - public static io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SearchReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v0.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviategrpc_SearchRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviategrpc_SearchRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviategrpc_SearchReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviategrpc_SearchReply_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\023v0/search_get.proto\022\014weaviategrpc\"\017\n\rS" + - "earchRequest\"\r\n\013SearchReplyBs\n#io.weavia" + - "te.client.grpc.protocol.v0B\026WeaviateProt" + - "oSearchGetZ4github.com/weaviate/weaviate" + - "/grpc/generated;protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - }); - internal_static_weaviategrpc_SearchRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviategrpc_SearchRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviategrpc_SearchRequest_descriptor, - new java.lang.String[] { }); - internal_static_weaviategrpc_SearchReply_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviategrpc_SearchReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviategrpc_SearchReply_descriptor, - new java.lang.String[] { }); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/FileReplicationServiceGrpc.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/FileReplicationServiceGrpc.java deleted file mode 100644 index 0b0b187ad..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/FileReplicationServiceGrpc.java +++ /dev/null @@ -1,557 +0,0 @@ -package io.weaviate.client.grpc.protocol.v1; - -import static io.grpc.MethodDescriptor.generateFullMethodName; - -/** - */ -@javax.annotation.Generated( - value = "by gRPC proto compiler (version 1.58.0)", - comments = "Source: v1/file_replication.proto") -@io.grpc.stub.annotations.GrpcGenerated -public final class FileReplicationServiceGrpc { - - private FileReplicationServiceGrpc() {} - - public static final java.lang.String SERVICE_NAME = "weaviate.v1.FileReplicationService"; - - // Static method descriptors that strictly reflect the proto. - private static volatile io.grpc.MethodDescriptor getPauseFileActivityMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "PauseFileActivity", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getPauseFileActivityMethod() { - io.grpc.MethodDescriptor getPauseFileActivityMethod; - if ((getPauseFileActivityMethod = FileReplicationServiceGrpc.getPauseFileActivityMethod) == null) { - synchronized (FileReplicationServiceGrpc.class) { - if ((getPauseFileActivityMethod = FileReplicationServiceGrpc.getPauseFileActivityMethod) == null) { - FileReplicationServiceGrpc.getPauseFileActivityMethod = getPauseFileActivityMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PauseFileActivity")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.getDefaultInstance())) - .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("PauseFileActivity")) - .build(); - } - } - } - return getPauseFileActivityMethod; - } - - private static volatile io.grpc.MethodDescriptor getResumeFileActivityMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "ResumeFileActivity", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getResumeFileActivityMethod() { - io.grpc.MethodDescriptor getResumeFileActivityMethod; - if ((getResumeFileActivityMethod = FileReplicationServiceGrpc.getResumeFileActivityMethod) == null) { - synchronized (FileReplicationServiceGrpc.class) { - if ((getResumeFileActivityMethod = FileReplicationServiceGrpc.getResumeFileActivityMethod) == null) { - FileReplicationServiceGrpc.getResumeFileActivityMethod = getResumeFileActivityMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResumeFileActivity")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.getDefaultInstance())) - .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("ResumeFileActivity")) - .build(); - } - } - } - return getResumeFileActivityMethod; - } - - private static volatile io.grpc.MethodDescriptor getListFilesMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "ListFiles", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getListFilesMethod() { - io.grpc.MethodDescriptor getListFilesMethod; - if ((getListFilesMethod = FileReplicationServiceGrpc.getListFilesMethod) == null) { - synchronized (FileReplicationServiceGrpc.class) { - if ((getListFilesMethod = FileReplicationServiceGrpc.getListFilesMethod) == null) { - FileReplicationServiceGrpc.getListFilesMethod = getListFilesMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListFiles")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.getDefaultInstance())) - .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("ListFiles")) - .build(); - } - } - } - return getListFilesMethod; - } - - private static volatile io.grpc.MethodDescriptor getGetFileMetadataMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "GetFileMetadata", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.class, - methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) - public static io.grpc.MethodDescriptor getGetFileMetadataMethod() { - io.grpc.MethodDescriptor getGetFileMetadataMethod; - if ((getGetFileMetadataMethod = FileReplicationServiceGrpc.getGetFileMetadataMethod) == null) { - synchronized (FileReplicationServiceGrpc.class) { - if ((getGetFileMetadataMethod = FileReplicationServiceGrpc.getGetFileMetadataMethod) == null) { - FileReplicationServiceGrpc.getGetFileMetadataMethod = getGetFileMetadataMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetFileMetadata")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.getDefaultInstance())) - .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("GetFileMetadata")) - .build(); - } - } - } - return getGetFileMetadataMethod; - } - - private static volatile io.grpc.MethodDescriptor getGetFileMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "GetFile", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.class, - methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) - public static io.grpc.MethodDescriptor getGetFileMethod() { - io.grpc.MethodDescriptor getGetFileMethod; - if ((getGetFileMethod = FileReplicationServiceGrpc.getGetFileMethod) == null) { - synchronized (FileReplicationServiceGrpc.class) { - if ((getGetFileMethod = FileReplicationServiceGrpc.getGetFileMethod) == null) { - FileReplicationServiceGrpc.getGetFileMethod = getGetFileMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetFile")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.getDefaultInstance())) - .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("GetFile")) - .build(); - } - } - } - return getGetFileMethod; - } - - /** - * Creates a new async stub that supports all call types for the service - */ - public static FileReplicationServiceStub newStub(io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public FileReplicationServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceStub(channel, callOptions); - } - }; - return FileReplicationServiceStub.newStub(factory, channel); - } - - /** - * Creates a new blocking-style stub that supports unary and streaming output calls on the service - */ - public static FileReplicationServiceBlockingStub newBlockingStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public FileReplicationServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceBlockingStub(channel, callOptions); - } - }; - return FileReplicationServiceBlockingStub.newStub(factory, channel); - } - - /** - * Creates a new ListenableFuture-style stub that supports unary calls on the service - */ - public static FileReplicationServiceFutureStub newFutureStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public FileReplicationServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceFutureStub(channel, callOptions); - } - }; - return FileReplicationServiceFutureStub.newStub(factory, channel); - } - - /** - */ - public interface AsyncService { - - /** - */ - default void pauseFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPauseFileActivityMethod(), responseObserver); - } - - /** - */ - default void resumeFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumeFileActivityMethod(), responseObserver); - } - - /** - */ - default void listFiles(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListFilesMethod(), responseObserver); - } - - /** - */ - default io.grpc.stub.StreamObserver getFileMetadata( - io.grpc.stub.StreamObserver responseObserver) { - return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getGetFileMetadataMethod(), responseObserver); - } - - /** - */ - default io.grpc.stub.StreamObserver getFile( - io.grpc.stub.StreamObserver responseObserver) { - return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getGetFileMethod(), responseObserver); - } - } - - /** - * Base class for the server implementation of the service FileReplicationService. - */ - public static abstract class FileReplicationServiceImplBase - implements io.grpc.BindableService, AsyncService { - - @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { - return FileReplicationServiceGrpc.bindService(this); - } - } - - /** - * A stub to allow clients to do asynchronous rpc calls to service FileReplicationService. - */ - public static final class FileReplicationServiceStub - extends io.grpc.stub.AbstractAsyncStub { - private FileReplicationServiceStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected FileReplicationServiceStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceStub(channel, callOptions); - } - - /** - */ - public void pauseFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getPauseFileActivityMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void resumeFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getResumeFileActivityMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void listFiles(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getListFilesMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public io.grpc.stub.StreamObserver getFileMetadata( - io.grpc.stub.StreamObserver responseObserver) { - return io.grpc.stub.ClientCalls.asyncBidiStreamingCall( - getChannel().newCall(getGetFileMetadataMethod(), getCallOptions()), responseObserver); - } - - /** - */ - public io.grpc.stub.StreamObserver getFile( - io.grpc.stub.StreamObserver responseObserver) { - return io.grpc.stub.ClientCalls.asyncBidiStreamingCall( - getChannel().newCall(getGetFileMethod(), getCallOptions()), responseObserver); - } - } - - /** - * A stub to allow clients to do synchronous rpc calls to service FileReplicationService. - */ - public static final class FileReplicationServiceBlockingStub - extends io.grpc.stub.AbstractBlockingStub { - private FileReplicationServiceBlockingStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected FileReplicationServiceBlockingStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceBlockingStub(channel, callOptions); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse pauseFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getPauseFileActivityMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse resumeFileActivity(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getResumeFileActivityMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse listFiles(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getListFilesMethod(), getCallOptions(), request); - } - } - - /** - * A stub to allow clients to do ListenableFuture-style rpc calls to service FileReplicationService. - */ - public static final class FileReplicationServiceFutureStub - extends io.grpc.stub.AbstractFutureStub { - private FileReplicationServiceFutureStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected FileReplicationServiceFutureStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new FileReplicationServiceFutureStub(channel, callOptions); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture pauseFileActivity( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getPauseFileActivityMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture resumeFileActivity( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getResumeFileActivityMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture listFiles( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getListFilesMethod(), getCallOptions()), request); - } - } - - private static final int METHODID_PAUSE_FILE_ACTIVITY = 0; - private static final int METHODID_RESUME_FILE_ACTIVITY = 1; - private static final int METHODID_LIST_FILES = 2; - private static final int METHODID_GET_FILE_METADATA = 3; - private static final int METHODID_GET_FILE = 4; - - 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 AsyncService serviceImpl; - private final int methodId; - - MethodHandlers(AsyncService 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_PAUSE_FILE_ACTIVITY: - serviceImpl.pauseFileActivity((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_RESUME_FILE_ACTIVITY: - serviceImpl.resumeFileActivity((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_LIST_FILES: - serviceImpl.listFiles((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest) 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_GET_FILE_METADATA: - return (io.grpc.stub.StreamObserver) serviceImpl.getFileMetadata( - (io.grpc.stub.StreamObserver) responseObserver); - case METHODID_GET_FILE: - return (io.grpc.stub.StreamObserver) serviceImpl.getFile( - (io.grpc.stub.StreamObserver) responseObserver); - default: - throw new AssertionError(); - } - } - } - - public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { - return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) - .addMethod( - getPauseFileActivityMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse>( - service, METHODID_PAUSE_FILE_ACTIVITY))) - .addMethod( - getResumeFileActivityMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse>( - service, METHODID_RESUME_FILE_ACTIVITY))) - .addMethod( - getListFilesMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse>( - service, METHODID_LIST_FILES))) - .addMethod( - getGetFileMetadataMethod(), - io.grpc.stub.ServerCalls.asyncBidiStreamingCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata>( - service, METHODID_GET_FILE_METADATA))) - .addMethod( - getGetFileMethod(), - io.grpc.stub.ServerCalls.asyncBidiStreamingCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk>( - service, METHODID_GET_FILE))) - .build(); - } - - private static abstract class FileReplicationServiceBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { - FileReplicationServiceBaseDescriptorSupplier() {} - - @java.lang.Override - public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.getDescriptor(); - } - - @java.lang.Override - public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { - return getFileDescriptor().findServiceByName("FileReplicationService"); - } - } - - private static final class FileReplicationServiceFileDescriptorSupplier - extends FileReplicationServiceBaseDescriptorSupplier { - FileReplicationServiceFileDescriptorSupplier() {} - } - - private static final class FileReplicationServiceMethodDescriptorSupplier - extends FileReplicationServiceBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { - private final java.lang.String methodName; - - FileReplicationServiceMethodDescriptorSupplier(java.lang.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 (FileReplicationServiceGrpc.class) { - result = serviceDescriptor; - if (result == null) { - serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) - .setSchemaDescriptor(new FileReplicationServiceFileDescriptorSupplier()) - .addMethod(getPauseFileActivityMethod()) - .addMethod(getResumeFileActivityMethod()) - .addMethod(getListFilesMethod()) - .addMethod(getGetFileMetadataMethod()) - .addMethod(getGetFileMethod()) - .build(); - } - } - } - return result; - } -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateFileReplicationService.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateFileReplicationService.java deleted file mode 100644 index 8e237d8c8..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateFileReplicationService.java +++ /dev/null @@ -1,8342 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/file_replication.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateFileReplicationService { - private WeaviateFileReplicationService() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - /** - * Protobuf enum {@code weaviate.v1.CompressionType} - */ - public enum CompressionType - implements com.google.protobuf.ProtocolMessageEnum { - /** - *
-     * No compression
-     * 
- * - * COMPRESSION_TYPE_UNSPECIFIED = 0; - */ - COMPRESSION_TYPE_UNSPECIFIED(0), - /** - *
-     * gzip (compress/gzip)
-     * 
- * - * COMPRESSION_TYPE_GZIP = 1; - */ - COMPRESSION_TYPE_GZIP(1), - /** - *
-     * zlib (compress/zlib)
-     * 
- * - * COMPRESSION_TYPE_ZLIB = 2; - */ - COMPRESSION_TYPE_ZLIB(2), - /** - *
-     * raw DEFLATE (compress/flate)
-     * 
- * - * COMPRESSION_TYPE_DEFLATE = 3; - */ - COMPRESSION_TYPE_DEFLATE(3), - UNRECOGNIZED(-1), - ; - - /** - *
-     * No compression
-     * 
- * - * COMPRESSION_TYPE_UNSPECIFIED = 0; - */ - public static final int COMPRESSION_TYPE_UNSPECIFIED_VALUE = 0; - /** - *
-     * gzip (compress/gzip)
-     * 
- * - * COMPRESSION_TYPE_GZIP = 1; - */ - public static final int COMPRESSION_TYPE_GZIP_VALUE = 1; - /** - *
-     * zlib (compress/zlib)
-     * 
- * - * COMPRESSION_TYPE_ZLIB = 2; - */ - public static final int COMPRESSION_TYPE_ZLIB_VALUE = 2; - /** - *
-     * raw DEFLATE (compress/flate)
-     * 
- * - * COMPRESSION_TYPE_DEFLATE = 3; - */ - public static final int COMPRESSION_TYPE_DEFLATE_VALUE = 3; - - - public final int getNumber() { - if (this == UNRECOGNIZED) { - throw new java.lang.IllegalArgumentException( - "Can't get the number of an unknown enum value."); - } - return value; - } - - /** - * @param value The numeric wire value of the corresponding enum entry. - * @return The enum associated with the given numeric wire value. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static CompressionType valueOf(int value) { - return forNumber(value); - } - - /** - * @param value The numeric wire value of the corresponding enum entry. - * @return The enum associated with the given numeric wire value. - */ - public static CompressionType forNumber(int value) { - switch (value) { - case 0: return COMPRESSION_TYPE_UNSPECIFIED; - case 1: return COMPRESSION_TYPE_GZIP; - case 2: return COMPRESSION_TYPE_ZLIB; - case 3: return COMPRESSION_TYPE_DEFLATE; - default: return null; - } - } - - public static com.google.protobuf.Internal.EnumLiteMap - internalGetValueMap() { - return internalValueMap; - } - private static final com.google.protobuf.Internal.EnumLiteMap< - CompressionType> internalValueMap = - new com.google.protobuf.Internal.EnumLiteMap() { - public CompressionType findValueByNumber(int number) { - return CompressionType.forNumber(number); - } - }; - - public final com.google.protobuf.Descriptors.EnumValueDescriptor - getValueDescriptor() { - if (this == UNRECOGNIZED) { - throw new java.lang.IllegalStateException( - "Can't get the descriptor of an unrecognized enum value."); - } - return getDescriptor().getValues().get(ordinal()); - } - public final com.google.protobuf.Descriptors.EnumDescriptor - getDescriptorForType() { - return getDescriptor(); - } - public static final com.google.protobuf.Descriptors.EnumDescriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.getDescriptor().getEnumTypes().get(0); - } - - private static final CompressionType[] VALUES = values(); - - public static CompressionType valueOf( - com.google.protobuf.Descriptors.EnumValueDescriptor desc) { - if (desc.getType() != getDescriptor()) { - throw new java.lang.IllegalArgumentException( - "EnumValueDescriptor is not for this type."); - } - if (desc.getIndex() == -1) { - return UNRECOGNIZED; - } - return VALUES[desc.getIndex()]; - } - - private final int value; - - private CompressionType(int value) { - this.value = value; - } - - // @@protoc_insertion_point(enum_scope:weaviate.v1.CompressionType) - } - - public interface PauseFileActivityRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - long getSchemaVersion(); - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} - */ - public static final class PauseFileActivityRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityRequest) - PauseFileActivityRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use PauseFileActivityRequest.newBuilder() to construct. - private PauseFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PauseFileActivityRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PauseFileActivityRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SCHEMA_VERSION_FIELD_NUMBER = 3; - private long schemaVersion_ = 0L; - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - @java.lang.Override - public long getSchemaVersion() { - return schemaVersion_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (schemaVersion_ != 0L) { - output.writeUInt64(3, schemaVersion_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (schemaVersion_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeUInt64Size(3, schemaVersion_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (getSchemaVersion() - != other.getSchemaVersion()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + SCHEMA_VERSION_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getSchemaVersion()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - schemaVersion_ = 0L; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.schemaVersion_ = schemaVersion_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (other.getSchemaVersion() != 0L) { - setSchemaVersion(other.getSchemaVersion()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 24: { - schemaVersion_ = input.readUInt64(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private long schemaVersion_ ; - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - @java.lang.Override - public long getSchemaVersion() { - return schemaVersion_; - } - /** - * uint64 schema_version = 3; - * @param value The schemaVersion to set. - * @return This builder for chaining. - */ - public Builder setSchemaVersion(long value) { - - schemaVersion_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * uint64 schema_version = 3; - * @return This builder for chaining. - */ - public Builder clearSchemaVersion() { - bitField0_ = (bitField0_ & ~0x00000004); - schemaVersion_ = 0L; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PauseFileActivityRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface PauseFileActivityResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} - */ - public static final class PauseFileActivityResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityResponse) - PauseFileActivityResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use PauseFileActivityResponse.newBuilder() to construct. - private PauseFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PauseFileActivityResponse() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PauseFileActivityResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PauseFileActivityResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.PauseFileActivityResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ResumeFileActivityRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} - */ - public static final class ResumeFileActivityRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityRequest) - ResumeFileActivityRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use ResumeFileActivityRequest.newBuilder() to construct. - private ResumeFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ResumeFileActivityRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ResumeFileActivityRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ResumeFileActivityRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ResumeFileActivityResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} - */ - public static final class ResumeFileActivityResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityResponse) - ResumeFileActivityResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use ResumeFileActivityResponse.newBuilder() to construct. - private ResumeFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ResumeFileActivityResponse() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ResumeFileActivityResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ResumeFileActivityResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ResumeFileActivityResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ListFilesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ListFilesRequest} - */ - public static final class ListFilesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesRequest) - ListFilesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use ListFilesRequest.newBuilder() to construct. - private ListFilesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ListFilesRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ListFilesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ListFilesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ListFilesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ListFilesResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - java.util.List - getFileNamesList(); - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - int getFileNamesCount(); - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - java.lang.String getFileNames(int index); - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - com.google.protobuf.ByteString - getFileNamesBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.ListFilesResponse} - */ - public static final class ListFilesResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesResponse) - ListFilesResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use ListFilesResponse.newBuilder() to construct. - private ListFilesResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ListFilesResponse() { - indexName_ = ""; - shardName_ = ""; - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ListFilesResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAMES_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - public com.google.protobuf.ProtocolStringList - getFileNamesList() { - return fileNames_; - } - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - public int getFileNamesCount() { - return fileNames_.size(); - } - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - public java.lang.String getFileNames(int index) { - return fileNames_.get(index); - } - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - public com.google.protobuf.ByteString - getFileNamesBytes(int index) { - return fileNames_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - for (int i = 0; i < fileNames_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileNames_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - { - int dataSize = 0; - for (int i = 0; i < fileNames_.size(); i++) { - dataSize += computeStringSizeNoTag(fileNames_.getRaw(i)); - } - size += dataSize; - size += 1 * getFileNamesList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileNamesList() - .equals(other.getFileNamesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - if (getFileNamesCount() > 0) { - hash = (37 * hash) + FILE_NAMES_FIELD_NUMBER; - hash = (53 * hash) + getFileNamesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ListFilesResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - fileNames_.makeImmutable(); - result.fileNames_ = fileNames_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.fileNames_.isEmpty()) { - if (fileNames_.isEmpty()) { - fileNames_ = other.fileNames_; - bitField0_ |= 0x00000004; - } else { - ensureFileNamesIsMutable(); - fileNames_.addAll(other.fileNames_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - java.lang.String s = input.readStringRequireUtf8(); - ensureFileNamesIsMutable(); - fileNames_.add(s); - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private com.google.protobuf.LazyStringArrayList fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureFileNamesIsMutable() { - if (!fileNames_.isModifiable()) { - fileNames_ = new com.google.protobuf.LazyStringArrayList(fileNames_); - } - bitField0_ |= 0x00000004; - } - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - public com.google.protobuf.ProtocolStringList - getFileNamesList() { - fileNames_.makeImmutable(); - return fileNames_; - } - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - public int getFileNamesCount() { - return fileNames_.size(); - } - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - public java.lang.String getFileNames(int index) { - return fileNames_.get(index); - } - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - public com.google.protobuf.ByteString - getFileNamesBytes(int index) { - return fileNames_.getByteString(index); - } - /** - * repeated string file_names = 3; - * @param index The index to set the value at. - * @param value The fileNames to set. - * @return This builder for chaining. - */ - public Builder setFileNames( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureFileNamesIsMutable(); - fileNames_.set(index, value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param value The fileNames to add. - * @return This builder for chaining. - */ - public Builder addFileNames( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureFileNamesIsMutable(); - fileNames_.add(value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param values The fileNames to add. - * @return This builder for chaining. - */ - public Builder addAllFileNames( - java.lang.Iterable values) { - ensureFileNamesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, fileNames_); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @return This builder for chaining. - */ - public Builder clearFileNames() { - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000004);; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param value The bytes of the fileNames to add. - * @return This builder for chaining. - */ - public Builder addFileNamesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureFileNamesIsMutable(); - fileNames_.add(value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ListFilesResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.ListFilesResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GetFileMetadataRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileMetadataRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} - */ - public static final class GetFileMetadataRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileMetadataRequest) - GetFileMetadataRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use GetFileMetadataRequest.newBuilder() to construct. - private GetFileMetadataRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GetFileMetadataRequest() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GetFileMetadataRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileMetadataRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileMetadataRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileMetadataRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GetFileMetadataRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileMetadataRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface FileMetadataOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.FileMetadata) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - - /** - * int64 size = 4; - * @return The size. - */ - long getSize(); - - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - int getCrc32(); - } - /** - * Protobuf type {@code weaviate.v1.FileMetadata} - */ - public static final class FileMetadata extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.FileMetadata) - FileMetadataOrBuilder { - private static final long serialVersionUID = 0L; - // Use FileMetadata.newBuilder() to construct. - private FileMetadata(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private FileMetadata() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new FileMetadata(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SIZE_FIELD_NUMBER = 4; - private long size_ = 0L; - /** - * int64 size = 4; - * @return The size. - */ - @java.lang.Override - public long getSize() { - return size_; - } - - public static final int CRC32_FIELD_NUMBER = 5; - private int crc32_ = 0; - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - @java.lang.Override - public int getCrc32() { - return crc32_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - if (size_ != 0L) { - output.writeInt64(4, size_); - } - if (crc32_ != 0) { - output.writeUInt32(5, crc32_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - if (size_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(4, size_); - } - if (crc32_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeUInt32Size(5, crc32_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (getSize() - != other.getSize()) return false; - if (getCrc32() - != other.getCrc32()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (37 * hash) + SIZE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getSize()); - hash = (37 * hash) + CRC32_FIELD_NUMBER; - hash = (53 * hash) + getCrc32(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.FileMetadata} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.FileMetadata) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadataOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - size_ = 0L; - crc32_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.size_ = size_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.crc32_ = crc32_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (other.getSize() != 0L) { - setSize(other.getSize()); - } - if (other.getCrc32() != 0) { - setCrc32(other.getCrc32()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 32: { - size_ = input.readInt64(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 40: { - crc32_ = input.readUInt32(); - bitField0_ |= 0x00000010; - break; - } // case 40 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private long size_ ; - /** - * int64 size = 4; - * @return The size. - */ - @java.lang.Override - public long getSize() { - return size_; - } - /** - * int64 size = 4; - * @param value The size to set. - * @return This builder for chaining. - */ - public Builder setSize(long value) { - - size_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * int64 size = 4; - * @return This builder for chaining. - */ - public Builder clearSize() { - bitField0_ = (bitField0_ & ~0x00000008); - size_ = 0L; - onChanged(); - return this; - } - - private int crc32_ ; - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - @java.lang.Override - public int getCrc32() { - return crc32_; - } - /** - * uint32 crc32 = 5; - * @param value The crc32 to set. - * @return This builder for chaining. - */ - public Builder setCrc32(int value) { - - crc32_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * uint32 crc32 = 5; - * @return This builder for chaining. - */ - public Builder clearCrc32() { - bitField0_ = (bitField0_ & ~0x00000010); - crc32_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.FileMetadata) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.FileMetadata) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public FileMetadata parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileMetadata getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GetFileRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - int getCompressionValue(); - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType getCompression(); - } - /** - * Protobuf type {@code weaviate.v1.GetFileRequest} - */ - public static final class GetFileRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileRequest) - GetFileRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use GetFileRequest.newBuilder() to construct. - private GetFileRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GetFileRequest() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - compression_ = 0; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GetFileRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int COMPRESSION_FIELD_NUMBER = 4; - private int compression_ = 0; - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - @java.lang.Override public int getCompressionValue() { - return compression_; - } - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType getCompression() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType result = io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.forNumber(compression_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.UNRECOGNIZED : result; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - if (compression_ != io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { - output.writeEnum(4, compression_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - if (compression_ != io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(4, compression_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (compression_ != other.compression_) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (37 * hash) + COMPRESSION_FIELD_NUMBER; - hash = (53 * hash) + compression_; - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GetFileRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - compression_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.compression_ = compression_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (other.compression_ != 0) { - setCompressionValue(other.getCompressionValue()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 32: { - compression_ = input.readEnum(); - bitField0_ |= 0x00000008; - break; - } // case 32 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private int compression_ = 0; - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - @java.lang.Override public int getCompressionValue() { - return compression_; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @param value The enum numeric value on the wire for compression to set. - * @return This builder for chaining. - */ - public Builder setCompressionValue(int value) { - compression_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType getCompression() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType result = io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.forNumber(compression_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType.UNRECOGNIZED : result; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @param value The compression to set. - * @return This builder for chaining. - */ - public Builder setCompression(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.CompressionType value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000008; - compression_ = value.getNumber(); - onChanged(); - return this; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return This builder for chaining. - */ - public Builder clearCompression() { - bitField0_ = (bitField0_ & ~0x00000008); - compression_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GetFileRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.GetFileRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface FileChunkOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.FileChunk) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     * Byte offset in the uncompressed file
-     * 
- * - * int64 offset = 1; - * @return The offset. - */ - long getOffset(); - - /** - *
-     * Compressed or raw chunk data
-     * 
- * - * bytes data = 2; - * @return The data. - */ - com.google.protobuf.ByteString getData(); - - /** - *
-     * Indicates final chunk
-     * 
- * - * bool eof = 3; - * @return The eof. - */ - boolean getEof(); - } - /** - * Protobuf type {@code weaviate.v1.FileChunk} - */ - public static final class FileChunk extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.FileChunk) - FileChunkOrBuilder { - private static final long serialVersionUID = 0L; - // Use FileChunk.newBuilder() to construct. - private FileChunk(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private FileChunk() { - data_ = com.google.protobuf.ByteString.EMPTY; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new FileChunk(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileChunk_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.Builder.class); - } - - public static final int OFFSET_FIELD_NUMBER = 1; - private long offset_ = 0L; - /** - *
-     * Byte offset in the uncompressed file
-     * 
- * - * int64 offset = 1; - * @return The offset. - */ - @java.lang.Override - public long getOffset() { - return offset_; - } - - public static final int DATA_FIELD_NUMBER = 2; - private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-     * Compressed or raw chunk data
-     * 
- * - * bytes data = 2; - * @return The data. - */ - @java.lang.Override - public com.google.protobuf.ByteString getData() { - return data_; - } - - public static final int EOF_FIELD_NUMBER = 3; - private boolean eof_ = false; - /** - *
-     * Indicates final chunk
-     * 
- * - * bool eof = 3; - * @return The eof. - */ - @java.lang.Override - public boolean getEof() { - return eof_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (offset_ != 0L) { - output.writeInt64(1, offset_); - } - if (!data_.isEmpty()) { - output.writeBytes(2, data_); - } - if (eof_ != false) { - output.writeBool(3, eof_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (offset_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(1, offset_); - } - if (!data_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(2, data_); - } - if (eof_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(3, eof_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk other = (io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk) obj; - - if (getOffset() - != other.getOffset()) return false; - if (!getData() - .equals(other.getData())) return false; - if (getEof() - != other.getEof()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + OFFSET_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getOffset()); - hash = (37 * hash) + DATA_FIELD_NUMBER; - hash = (53 * hash) + getData().hashCode(); - hash = (37 * hash) + EOF_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getEof()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.FileChunk} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.FileChunk) - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunkOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileChunk_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.class, io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - offset_ = 0L; - data_ = com.google.protobuf.ByteString.EMPTY; - eof_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk build() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk result = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.offset_ = offset_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.data_ = data_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.eof_ = eof_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk.getDefaultInstance()) return this; - if (other.getOffset() != 0L) { - setOffset(other.getOffset()); - } - if (other.getData() != com.google.protobuf.ByteString.EMPTY) { - setData(other.getData()); - } - if (other.getEof() != false) { - setEof(other.getEof()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - offset_ = input.readInt64(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - data_ = input.readBytes(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 24: { - eof_ = input.readBool(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private long offset_ ; - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @return The offset. - */ - @java.lang.Override - public long getOffset() { - return offset_; - } - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @param value The offset to set. - * @return This builder for chaining. - */ - public Builder setOffset(long value) { - - offset_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @return This builder for chaining. - */ - public Builder clearOffset() { - bitField0_ = (bitField0_ & ~0x00000001); - offset_ = 0L; - onChanged(); - return this; - } - - private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @return The data. - */ - @java.lang.Override - public com.google.protobuf.ByteString getData() { - return data_; - } - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @param value The data to set. - * @return This builder for chaining. - */ - public Builder setData(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - data_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @return This builder for chaining. - */ - public Builder clearData() { - bitField0_ = (bitField0_ & ~0x00000002); - data_ = getDefaultInstance().getData(); - onChanged(); - return this; - } - - private boolean eof_ ; - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @return The eof. - */ - @java.lang.Override - public boolean getEof() { - return eof_; - } - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @param value The eof to set. - * @return This builder for chaining. - */ - public Builder setEof(boolean value) { - - eof_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @return This builder for chaining. - */ - public Builder clearEof() { - bitField0_ = (bitField0_ & ~0x00000004); - eof_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.FileChunk) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.FileChunk) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public FileChunk parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateFileReplicationService.FileChunk getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ListFilesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ListFilesResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_FileMetadata_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_FileMetadata_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GetFileRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_FileChunk_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_FileChunk_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\031v1/file_replication.proto\022\013weaviate.v1" + - "\"Z\n\030PauseFileActivityRequest\022\022\n\nindex_na" + - "me\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\026\n\016schema_v" + - "ersion\030\003 \001(\004\"C\n\031PauseFileActivityRespons" + - "e\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(" + - "\t\"C\n\031ResumeFileActivityRequest\022\022\n\nindex_" + - "name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\"D\n\032Resume" + - "FileActivityResponse\022\022\n\nindex_name\030\001 \001(\t" + - "\022\022\n\nshard_name\030\002 \001(\t\":\n\020ListFilesRequest" + - "\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t" + - "\"O\n\021ListFilesResponse\022\022\n\nindex_name\030\001 \001(" + - "\t\022\022\n\nshard_name\030\002 \001(\t\022\022\n\nfile_names\030\003 \003(" + - "\t\"S\n\026GetFileMetadataRequest\022\022\n\nindex_nam" + - "e\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name" + - "\030\003 \001(\t\"f\n\014FileMetadata\022\022\n\nindex_name\030\001 \001" + - "(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(" + - "\t\022\014\n\004size\030\004 \001(\003\022\r\n\005crc32\030\005 \001(\r\"~\n\016GetFil" + - "eRequest\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_na" + - "me\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(\t\0221\n\013compressi" + - "on\030\004 \001(\0162\034.weaviate.v1.CompressionType\"6" + - "\n\tFileChunk\022\016\n\006offset\030\001 \001(\003\022\014\n\004data\030\002 \001(" + - "\014\022\013\n\003eof\030\003 \001(\010*\207\001\n\017CompressionType\022 \n\034CO" + - "MPRESSION_TYPE_UNSPECIFIED\020\000\022\031\n\025COMPRESS" + - "ION_TYPE_GZIP\020\001\022\031\n\025COMPRESSION_TYPE_ZLIB" + - "\020\002\022\034\n\030COMPRESSION_TYPE_DEFLATE\020\0032\312\003\n\026Fil" + - "eReplicationService\022b\n\021PauseFileActivity" + - "\022%.weaviate.v1.PauseFileActivityRequest\032" + - "&.weaviate.v1.PauseFileActivityResponse\022" + - "e\n\022ResumeFileActivity\022&.weaviate.v1.Resu" + - "meFileActivityRequest\032\'.weaviate.v1.Resu" + - "meFileActivityResponse\022J\n\tListFiles\022\035.we" + - "aviate.v1.ListFilesRequest\032\036.weaviate.v1" + - ".ListFilesResponse\022U\n\017GetFileMetadata\022#." + - "weaviate.v1.GetFileMetadataRequest\032\031.wea" + - "viate.v1.FileMetadata(\0010\001\022B\n\007GetFile\022\033.w" + - "eaviate.v1.GetFileRequest\032\026.weaviate.v1." + - "FileChunk(\0010\001B{\n#io.weaviate.client.grpc" + - ".protocol.v1B\036WeaviateFileReplicationSer" + - "viceZ4github.com/weaviate/weaviate/grpc/" + - "generated;protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - }); - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "SchemaVersion", }); - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ListFilesRequest_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ListFilesRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ListFilesResponse_descriptor = - getDescriptor().getMessageTypes().get(5); - internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ListFilesResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileNames", }); - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor = - getDescriptor().getMessageTypes().get(6); - internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", }); - internal_static_weaviate_v1_FileMetadata_descriptor = - getDescriptor().getMessageTypes().get(7); - internal_static_weaviate_v1_FileMetadata_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_FileMetadata_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", "Size", "Crc32", }); - internal_static_weaviate_v1_GetFileRequest_descriptor = - getDescriptor().getMessageTypes().get(8); - internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GetFileRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", "Compression", }); - internal_static_weaviate_v1_FileChunk_descriptor = - getDescriptor().getMessageTypes().get(9); - internal_static_weaviate_v1_FileChunk_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_FileChunk_descriptor, - new java.lang.String[] { "Offset", "Data", "Eof", }); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateGrpc.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateGrpc.java deleted file mode 100644 index 75ab63d02..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateGrpc.java +++ /dev/null @@ -1,804 +0,0 @@ -package io.weaviate.client.grpc.protocol.v1; - -import static io.grpc.MethodDescriptor.generateFullMethodName; - -/** - */ -@javax.annotation.Generated( - value = "by gRPC proto compiler (version 1.58.0)", - comments = "Source: v1/weaviate.proto") -@io.grpc.stub.annotations.GrpcGenerated -public final class WeaviateGrpc { - - private WeaviateGrpc() {} - - public static final java.lang.String SERVICE_NAME = "weaviate.v1.Weaviate"; - - // Static method descriptors that strictly reflect the proto. - private static volatile io.grpc.MethodDescriptor getSearchMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "Search", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getSearchMethod() { - io.grpc.MethodDescriptor getSearchMethod; - if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { - WeaviateGrpc.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( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("Search")) - .build(); - } - } - } - return getSearchMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchObjectsMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchObjects", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getBatchObjectsMethod() { - io.grpc.MethodDescriptor getBatchObjectsMethod; - if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { - WeaviateGrpc.getBatchObjectsMethod = getBatchObjectsMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchObjects")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchObjects")) - .build(); - } - } - } - return getBatchObjectsMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchReferencesMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchReferences", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getBatchReferencesMethod() { - io.grpc.MethodDescriptor getBatchReferencesMethod; - if ((getBatchReferencesMethod = WeaviateGrpc.getBatchReferencesMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchReferencesMethod = WeaviateGrpc.getBatchReferencesMethod) == null) { - WeaviateGrpc.getBatchReferencesMethod = getBatchReferencesMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchReferences")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchReferences")) - .build(); - } - } - } - return getBatchReferencesMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchDeleteMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchDelete", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getBatchDeleteMethod() { - io.grpc.MethodDescriptor getBatchDeleteMethod; - if ((getBatchDeleteMethod = WeaviateGrpc.getBatchDeleteMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchDeleteMethod = WeaviateGrpc.getBatchDeleteMethod) == null) { - WeaviateGrpc.getBatchDeleteMethod = getBatchDeleteMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchDelete")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchDelete")) - .build(); - } - } - } - return getBatchDeleteMethod; - } - - private static volatile io.grpc.MethodDescriptor getTenantsGetMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "TenantsGet", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getTenantsGetMethod() { - io.grpc.MethodDescriptor getTenantsGetMethod; - if ((getTenantsGetMethod = WeaviateGrpc.getTenantsGetMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getTenantsGetMethod = WeaviateGrpc.getTenantsGetMethod) == null) { - WeaviateGrpc.getTenantsGetMethod = getTenantsGetMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "TenantsGet")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("TenantsGet")) - .build(); - } - } - } - return getTenantsGetMethod; - } - - private static volatile io.grpc.MethodDescriptor getAggregateMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "Aggregate", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getAggregateMethod() { - io.grpc.MethodDescriptor getAggregateMethod; - if ((getAggregateMethod = WeaviateGrpc.getAggregateMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getAggregateMethod = WeaviateGrpc.getAggregateMethod) == null) { - WeaviateGrpc.getAggregateMethod = getAggregateMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Aggregate")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("Aggregate")) - .build(); - } - } - } - return getAggregateMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchSendMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchSend", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.class, - methodType = io.grpc.MethodDescriptor.MethodType.UNARY) - public static io.grpc.MethodDescriptor getBatchSendMethod() { - io.grpc.MethodDescriptor getBatchSendMethod; - if ((getBatchSendMethod = WeaviateGrpc.getBatchSendMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchSendMethod = WeaviateGrpc.getBatchSendMethod) == null) { - WeaviateGrpc.getBatchSendMethod = getBatchSendMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchSend")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchSend")) - .build(); - } - } - } - return getBatchSendMethod; - } - - private static volatile io.grpc.MethodDescriptor getBatchStreamMethod; - - @io.grpc.stub.annotations.RpcMethod( - fullMethodName = SERVICE_NAME + '/' + "BatchStream", - requestType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.class, - responseType = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.class, - methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) - public static io.grpc.MethodDescriptor getBatchStreamMethod() { - io.grpc.MethodDescriptor getBatchStreamMethod; - if ((getBatchStreamMethod = WeaviateGrpc.getBatchStreamMethod) == null) { - synchronized (WeaviateGrpc.class) { - if ((getBatchStreamMethod = WeaviateGrpc.getBatchStreamMethod) == null) { - WeaviateGrpc.getBatchStreamMethod = getBatchStreamMethod = - io.grpc.MethodDescriptor.newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) - .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchStream")) - .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance())) - .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchStream")) - .build(); - } - } - } - return getBatchStreamMethod; - } - - /** - * Creates a new async stub that supports all call types for the service - */ - public static WeaviateStub newStub(io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateStub(channel, callOptions); - } - }; - return WeaviateStub.newStub(factory, channel); - } - - /** - * Creates a new blocking-style stub that supports unary and streaming output calls on the service - */ - public static WeaviateBlockingStub newBlockingStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateBlockingStub(channel, callOptions); - } - }; - return WeaviateBlockingStub.newStub(factory, channel); - } - - /** - * Creates a new ListenableFuture-style stub that supports unary calls on the service - */ - public static WeaviateFutureStub newFutureStub( - io.grpc.Channel channel) { - io.grpc.stub.AbstractStub.StubFactory factory = - new io.grpc.stub.AbstractStub.StubFactory() { - @java.lang.Override - public WeaviateFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateFutureStub(channel, callOptions); - } - }; - return WeaviateFutureStub.newStub(factory, channel); - } - - /** - */ - public interface AsyncService { - - /** - */ - default void search(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSearchMethod(), responseObserver); - } - - /** - */ - default void batchObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchObjectsMethod(), responseObserver); - } - - /** - */ - default void batchReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchReferencesMethod(), responseObserver); - } - - /** - */ - default void batchDelete(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchDeleteMethod(), responseObserver); - } - - /** - */ - default void tenantsGet(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getTenantsGetMethod(), responseObserver); - } - - /** - */ - default void aggregate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAggregateMethod(), responseObserver); - } - - /** - */ - default void batchSend(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchSendMethod(), responseObserver); - } - - /** - */ - default void batchStream(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchStreamMethod(), responseObserver); - } - } - - /** - * Base class for the server implementation of the service Weaviate. - */ - public static abstract class WeaviateImplBase - implements io.grpc.BindableService, AsyncService { - - @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { - return WeaviateGrpc.bindService(this); - } - } - - /** - * A stub to allow clients to do asynchronous rpc calls to service Weaviate. - */ - public static final class WeaviateStub - extends io.grpc.stub.AbstractAsyncStub { - private WeaviateStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateStub(channel, callOptions); - } - - /** - */ - public void search(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getSearchMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getBatchReferencesMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchDelete(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getBatchDeleteMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void tenantsGet(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getTenantsGetMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void aggregate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getAggregateMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchSend(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncUnaryCall( - getChannel().newCall(getBatchSendMethod(), getCallOptions()), request, responseObserver); - } - - /** - */ - public void batchStream(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest request, - io.grpc.stub.StreamObserver responseObserver) { - io.grpc.stub.ClientCalls.asyncServerStreamingCall( - getChannel().newCall(getBatchStreamMethod(), getCallOptions()), request, responseObserver); - } - } - - /** - * A stub to allow clients to do synchronous rpc calls to service Weaviate. - */ - public static final class WeaviateBlockingStub - extends io.grpc.stub.AbstractBlockingStub { - private WeaviateBlockingStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateBlockingStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateBlockingStub(channel, callOptions); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply search(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getSearchMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply batchObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getBatchObjectsMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply batchReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getBatchReferencesMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply batchDelete(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getBatchDeleteMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply tenantsGet(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getTenantsGetMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply aggregate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getAggregateMethod(), getCallOptions(), request); - } - - /** - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply batchSend(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest request) { - return io.grpc.stub.ClientCalls.blockingUnaryCall( - getChannel(), getBatchSendMethod(), getCallOptions(), request); - } - - /** - */ - public java.util.Iterator batchStream( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest request) { - return io.grpc.stub.ClientCalls.blockingServerStreamingCall( - getChannel(), getBatchStreamMethod(), getCallOptions(), request); - } - } - - /** - * A stub to allow clients to do ListenableFuture-style rpc calls to service Weaviate. - */ - public static final class WeaviateFutureStub - extends io.grpc.stub.AbstractFutureStub { - private WeaviateFutureStub( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - super(channel, callOptions); - } - - @java.lang.Override - protected WeaviateFutureStub build( - io.grpc.Channel channel, io.grpc.CallOptions callOptions) { - return new WeaviateFutureStub(channel, callOptions); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture search( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getSearchMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture batchObjects( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture batchReferences( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getBatchReferencesMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture batchDelete( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getBatchDeleteMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture tenantsGet( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getTenantsGetMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture aggregate( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getAggregateMethod(), getCallOptions()), request); - } - - /** - */ - public com.google.common.util.concurrent.ListenableFuture batchSend( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest request) { - return io.grpc.stub.ClientCalls.futureUnaryCall( - getChannel().newCall(getBatchSendMethod(), getCallOptions()), request); - } - } - - private static final int METHODID_SEARCH = 0; - private static final int METHODID_BATCH_OBJECTS = 1; - private static final int METHODID_BATCH_REFERENCES = 2; - private static final int METHODID_BATCH_DELETE = 3; - private static final int METHODID_TENANTS_GET = 4; - private static final int METHODID_AGGREGATE = 5; - private static final int METHODID_BATCH_SEND = 6; - private static final int METHODID_BATCH_STREAM = 7; - - 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 AsyncService serviceImpl; - private final int methodId; - - MethodHandlers(AsyncService 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_SEARCH: - serviceImpl.search((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_OBJECTS: - serviceImpl.batchObjects((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_REFERENCES: - serviceImpl.batchReferences((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_DELETE: - serviceImpl.batchDelete((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_TENANTS_GET: - serviceImpl.tenantsGet((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_AGGREGATE: - serviceImpl.aggregate((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_SEND: - serviceImpl.batchSend((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest) request, - (io.grpc.stub.StreamObserver) responseObserver); - break; - case METHODID_BATCH_STREAM: - serviceImpl.batchStream((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest) 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(); - } - } - } - - public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { - return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) - .addMethod( - getSearchMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply>( - service, METHODID_SEARCH))) - .addMethod( - getBatchObjectsMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply>( - service, METHODID_BATCH_OBJECTS))) - .addMethod( - getBatchReferencesMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply>( - service, METHODID_BATCH_REFERENCES))) - .addMethod( - getBatchDeleteMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply>( - service, METHODID_BATCH_DELETE))) - .addMethod( - getTenantsGetMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply>( - service, METHODID_TENANTS_GET))) - .addMethod( - getAggregateMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply>( - service, METHODID_AGGREGATE))) - .addMethod( - getBatchSendMethod(), - io.grpc.stub.ServerCalls.asyncUnaryCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply>( - service, METHODID_BATCH_SEND))) - .addMethod( - getBatchStreamMethod(), - io.grpc.stub.ServerCalls.asyncServerStreamingCall( - new MethodHandlers< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage>( - service, METHODID_BATCH_STREAM))) - .build(); - } - - private static abstract class WeaviateBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { - WeaviateBaseDescriptorSupplier() {} - - @java.lang.Override - public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProto.getDescriptor(); - } - - @java.lang.Override - public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { - return getFileDescriptor().findServiceByName("Weaviate"); - } - } - - private static final class WeaviateFileDescriptorSupplier - extends WeaviateBaseDescriptorSupplier { - WeaviateFileDescriptorSupplier() {} - } - - private static final class WeaviateMethodDescriptorSupplier - extends WeaviateBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { - private final java.lang.String methodName; - - WeaviateMethodDescriptorSupplier(java.lang.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 (WeaviateGrpc.class) { - result = serviceDescriptor; - if (result == null) { - serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) - .setSchemaDescriptor(new WeaviateFileDescriptorSupplier()) - .addMethod(getSearchMethod()) - .addMethod(getBatchObjectsMethod()) - .addMethod(getBatchReferencesMethod()) - .addMethod(getBatchDeleteMethod()) - .addMethod(getTenantsGetMethod()) - .addMethod(getAggregateMethod()) - .addMethod(getBatchSendMethod()) - .addMethod(getBatchStreamMethod()) - .build(); - } - } - } - return result; - } -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProto.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProto.java deleted file mode 100644 index 1c09c3dc1..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProto.java +++ /dev/null @@ -1,67 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/weaviate.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateProto { - private WeaviateProto() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\021v1/weaviate.proto\022\013weaviate.v1\032\022v1/agg" + - "regate.proto\032\016v1/batch.proto\032\025v1/batch_d" + - "elete.proto\032\023v1/search_get.proto\032\020v1/ten" + - "ants.proto2\207\005\n\010Weaviate\022@\n\006Search\022\032.weav" + - "iate.v1.SearchRequest\032\030.weaviate.v1.Sear" + - "chReply\"\000\022R\n\014BatchObjects\022 .weaviate.v1." + - "BatchObjectsRequest\032\036.weaviate.v1.BatchO" + - "bjectsReply\"\000\022[\n\017BatchReferences\022#.weavi" + - "ate.v1.BatchReferencesRequest\032!.weaviate" + - ".v1.BatchReferencesReply\"\000\022O\n\013BatchDelet" + - "e\022\037.weaviate.v1.BatchDeleteRequest\032\035.wea" + - "viate.v1.BatchDeleteReply\"\000\022L\n\nTenantsGe" + - "t\022\036.weaviate.v1.TenantsGetRequest\032\034.weav" + - "iate.v1.TenantsGetReply\"\000\022I\n\tAggregate\022\035" + - ".weaviate.v1.AggregateRequest\032\033.weaviate" + - ".v1.AggregateReply\"\000\022I\n\tBatchSend\022\035.weav" + - "iate.v1.BatchSendRequest\032\033.weaviate.v1.B" + - "atchSendReply\"\000\022S\n\013BatchStream\022\037.weaviat" + - "e.v1.BatchStreamRequest\032\037.weaviate.v1.Ba" + - "tchStreamMessage\"\0000\001Bj\n#io.weaviate.clie" + - "nt.grpc.protocol.v1B\rWeaviateProtoZ4gith" + - "ub.com/weaviate/weaviate/grpc/generated;" + - "protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.getDescriptor(), - }); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.getDescriptor(); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatch.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatch.java deleted file mode 100644 index 7f8e77993..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatch.java +++ /dev/null @@ -1,22687 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/batch.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateProtoBatch { - private WeaviateProtoBatch() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - public interface BatchObjectsRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - java.util.List - getObjectsList(); - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getObjects(int index); - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - int getObjectsCount(); - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - java.util.List - getObjectsOrBuilderList(); - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder( - int index); - - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - boolean hasConsistencyLevel(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - int getConsistencyLevelValue(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsRequest} - */ - public static final class BatchObjectsRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsRequest) - BatchObjectsRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchObjectsRequest.newBuilder() to construct. - private BatchObjectsRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchObjectsRequest() { - objects_ = java.util.Collections.emptyList(); - consistencyLevel_ = 0; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchObjectsRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.Builder.class); - } - - private int bitField0_; - public static final int OBJECTS_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List objects_; - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - @java.lang.Override - public java.util.List getObjectsList() { - return objects_; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - @java.lang.Override - public java.util.List - getObjectsOrBuilderList() { - return objects_; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - @java.lang.Override - public int getObjectsCount() { - return objects_.size(); - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getObjects(int index) { - return objects_.get(index); - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder( - int index) { - return objects_.get(index); - } - - public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 2; - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < objects_.size(); i++) { - output.writeMessage(1, objects_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeEnum(2, consistencyLevel_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < objects_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, objects_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(2, consistencyLevel_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest) obj; - - if (!getObjectsList() - .equals(other.getObjectsList())) return false; - if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false; - if (hasConsistencyLevel()) { - if (consistencyLevel_ != other.consistencyLevel_) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getObjectsCount() > 0) { - hash = (37 * hash) + OBJECTS_FIELD_NUMBER; - hash = (53 * hash) + getObjectsList().hashCode(); - } - if (hasConsistencyLevel()) { - hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER; - hash = (53 * hash) + consistencyLevel_; - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (objectsBuilder_ == null) { - objects_ = java.util.Collections.emptyList(); - } else { - objects_ = null; - objectsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - consistencyLevel_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest result) { - if (objectsBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - objects_ = java.util.Collections.unmodifiableList(objects_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.objects_ = objects_; - } else { - result.objects_ = objectsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest result) { - int from_bitField0_ = bitField0_; - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.consistencyLevel_ = consistencyLevel_; - to_bitField0_ |= 0x00000001; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance()) return this; - if (objectsBuilder_ == null) { - if (!other.objects_.isEmpty()) { - if (objects_.isEmpty()) { - objects_ = other.objects_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureObjectsIsMutable(); - objects_.addAll(other.objects_); - } - onChanged(); - } - } else { - if (!other.objects_.isEmpty()) { - if (objectsBuilder_.isEmpty()) { - objectsBuilder_.dispose(); - objectsBuilder_ = null; - objects_ = other.objects_; - bitField0_ = (bitField0_ & ~0x00000001); - objectsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectsFieldBuilder() : null; - } else { - objectsBuilder_.addAllMessages(other.objects_); - } - } - } - if (other.hasConsistencyLevel()) { - setConsistencyLevel(other.getConsistencyLevel()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.parser(), - extensionRegistry); - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(m); - } else { - objectsBuilder_.addMessage(m); - } - break; - } // case 10 - case 16: { - consistencyLevel_ = input.readEnum(); - bitField0_ |= 0x00000002; - break; - } // case 16 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List objects_ = - java.util.Collections.emptyList(); - private void ensureObjectsIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - objects_ = new java.util.ArrayList(objects_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder> objectsBuilder_; - - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public java.util.List getObjectsList() { - if (objectsBuilder_ == null) { - return java.util.Collections.unmodifiableList(objects_); - } else { - return objectsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public int getObjectsCount() { - if (objectsBuilder_ == null) { - return objects_.size(); - } else { - return objectsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getObjects(int index) { - if (objectsBuilder_ == null) { - return objects_.get(index); - } else { - return objectsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.set(index, value); - onChanged(); - } else { - objectsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.set(index, builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder addObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.add(value); - onChanged(); - } else { - objectsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.add(index, value); - onChanged(); - } else { - objectsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder addObjects( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(index, builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder addAllObjects( - java.lang.Iterable values) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objects_); - onChanged(); - } else { - objectsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder clearObjects() { - if (objectsBuilder_ == null) { - objects_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - objectsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public Builder removeObjects(int index) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.remove(index); - onChanged(); - } else { - objectsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder getObjectsBuilder( - int index) { - return getObjectsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder( - int index) { - if (objectsBuilder_ == null) { - return objects_.get(index); } else { - return objectsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public java.util.List - getObjectsOrBuilderList() { - if (objectsBuilder_ != null) { - return objectsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objects_); - } - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder addObjectsBuilder() { - return getObjectsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder addObjectsBuilder( - int index) { - return getObjectsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject objects = 1; - */ - public java.util.List - getObjectsBuilderList() { - return getObjectsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder> - getObjectsFieldBuilder() { - if (objectsBuilder_ == null) { - objectsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder>( - objects_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - objects_ = null; - } - return objectsBuilder_; - } - - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @param value The enum numeric value on the wire for consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevelValue(int value) { - consistencyLevel_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @param value The consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevel(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000002; - consistencyLevel_ = value.getNumber(); - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return This builder for chaining. - */ - public Builder clearConsistencyLevel() { - bitField0_ = (bitField0_ & ~0x00000002); - consistencyLevel_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchObjectsRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchReferencesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - java.util.List - getReferencesList(); - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getReferences(int index); - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - int getReferencesCount(); - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - java.util.List - getReferencesOrBuilderList(); - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder( - int index); - - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - boolean hasConsistencyLevel(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - int getConsistencyLevelValue(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesRequest} - */ - public static final class BatchReferencesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesRequest) - BatchReferencesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchReferencesRequest.newBuilder() to construct. - private BatchReferencesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchReferencesRequest() { - references_ = java.util.Collections.emptyList(); - consistencyLevel_ = 0; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchReferencesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.Builder.class); - } - - private int bitField0_; - public static final int REFERENCES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List references_; - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - @java.lang.Override - public java.util.List getReferencesList() { - return references_; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - @java.lang.Override - public java.util.List - getReferencesOrBuilderList() { - return references_; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - @java.lang.Override - public int getReferencesCount() { - return references_.size(); - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getReferences(int index) { - return references_.get(index); - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder( - int index) { - return references_.get(index); - } - - public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 2; - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < references_.size(); i++) { - output.writeMessage(1, references_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeEnum(2, consistencyLevel_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < references_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, references_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(2, consistencyLevel_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest) obj; - - if (!getReferencesList() - .equals(other.getReferencesList())) return false; - if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false; - if (hasConsistencyLevel()) { - if (consistencyLevel_ != other.consistencyLevel_) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getReferencesCount() > 0) { - hash = (37 * hash) + REFERENCES_FIELD_NUMBER; - hash = (53 * hash) + getReferencesList().hashCode(); - } - if (hasConsistencyLevel()) { - hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER; - hash = (53 * hash) + consistencyLevel_; - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (referencesBuilder_ == null) { - references_ = java.util.Collections.emptyList(); - } else { - references_ = null; - referencesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - consistencyLevel_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest result) { - if (referencesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - references_ = java.util.Collections.unmodifiableList(references_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.references_ = references_; - } else { - result.references_ = referencesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest result) { - int from_bitField0_ = bitField0_; - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.consistencyLevel_ = consistencyLevel_; - to_bitField0_ |= 0x00000001; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance()) return this; - if (referencesBuilder_ == null) { - if (!other.references_.isEmpty()) { - if (references_.isEmpty()) { - references_ = other.references_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureReferencesIsMutable(); - references_.addAll(other.references_); - } - onChanged(); - } - } else { - if (!other.references_.isEmpty()) { - if (referencesBuilder_.isEmpty()) { - referencesBuilder_.dispose(); - referencesBuilder_ = null; - references_ = other.references_; - bitField0_ = (bitField0_ & ~0x00000001); - referencesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getReferencesFieldBuilder() : null; - } else { - referencesBuilder_.addAllMessages(other.references_); - } - } - } - if (other.hasConsistencyLevel()) { - setConsistencyLevel(other.getConsistencyLevel()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.parser(), - extensionRegistry); - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - references_.add(m); - } else { - referencesBuilder_.addMessage(m); - } - break; - } // case 10 - case 16: { - consistencyLevel_ = input.readEnum(); - bitField0_ |= 0x00000002; - break; - } // case 16 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List references_ = - java.util.Collections.emptyList(); - private void ensureReferencesIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - references_ = new java.util.ArrayList(references_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder> referencesBuilder_; - - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public java.util.List getReferencesList() { - if (referencesBuilder_ == null) { - return java.util.Collections.unmodifiableList(references_); - } else { - return referencesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public int getReferencesCount() { - if (referencesBuilder_ == null) { - return references_.size(); - } else { - return referencesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getReferences(int index) { - if (referencesBuilder_ == null) { - return references_.get(index); - } else { - return referencesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder setReferences( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (referencesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureReferencesIsMutable(); - references_.set(index, value); - onChanged(); - } else { - referencesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder setReferences( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - references_.set(index, builderForValue.build()); - onChanged(); - } else { - referencesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder addReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (referencesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureReferencesIsMutable(); - references_.add(value); - onChanged(); - } else { - referencesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder addReferences( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (referencesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureReferencesIsMutable(); - references_.add(index, value); - onChanged(); - } else { - referencesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder addReferences( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - references_.add(builderForValue.build()); - onChanged(); - } else { - referencesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder addReferences( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - references_.add(index, builderForValue.build()); - onChanged(); - } else { - referencesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder addAllReferences( - java.lang.Iterable values) { - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, references_); - onChanged(); - } else { - referencesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder clearReferences() { - if (referencesBuilder_ == null) { - references_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - referencesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public Builder removeReferences(int index) { - if (referencesBuilder_ == null) { - ensureReferencesIsMutable(); - references_.remove(index); - onChanged(); - } else { - referencesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder getReferencesBuilder( - int index) { - return getReferencesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder( - int index) { - if (referencesBuilder_ == null) { - return references_.get(index); } else { - return referencesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public java.util.List - getReferencesOrBuilderList() { - if (referencesBuilder_ != null) { - return referencesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(references_); - } - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder addReferencesBuilder() { - return getReferencesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder addReferencesBuilder( - int index) { - return getReferencesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReference references = 1; - */ - public java.util.List - getReferencesBuilderList() { - return getReferencesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder> - getReferencesFieldBuilder() { - if (referencesBuilder_ == null) { - referencesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder>( - references_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - references_ = null; - } - return referencesBuilder_; - } - - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @param value The enum numeric value on the wire for consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevelValue(int value) { - consistencyLevel_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return The consistencyLevel. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @param value The consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevel(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000002; - consistencyLevel_ = value.getNumber(); - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 2; - * @return This builder for chaining. - */ - public Builder clearConsistencyLevel() { - bitField0_ = (bitField0_ & ~0x00000002); - consistencyLevel_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchReferencesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchSendRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string stream_id = 1; - * @return The streamId. - */ - java.lang.String getStreamId(); - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - com.google.protobuf.ByteString - getStreamIdBytes(); - - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return Whether the objects field is set. - */ - boolean hasObjects(); - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return The objects. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getObjects(); - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder(); - - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return Whether the references field is set. - */ - boolean hasReferences(); - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return The references. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getReferences(); - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder(); - - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return Whether the stop field is set. - */ - boolean hasStop(); - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return The stop. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getStop(); - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder(); - - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.MessageCase getMessageCase(); - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest} - */ - public static final class BatchSendRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest) - BatchSendRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchSendRequest.newBuilder() to construct. - private BatchSendRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchSendRequest() { - streamId_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchSendRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Builder.class); - } - - public interface StopOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.Stop) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.Stop} - */ - public static final class Stop extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.Stop) - StopOrBuilder { - private static final long serialVersionUID = 0L; - // Use Stop.newBuilder() to construct. - private Stop(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Stop() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Stop(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.Stop} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.Stop) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.Stop) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.Stop) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Stop parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ObjectsOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.Objects) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - java.util.List - getValuesList(); - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getValues(int index); - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - int getValuesCount(); - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - java.util.List - getValuesOrBuilderList(); - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.Objects} - */ - public static final class Objects extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.Objects) - ObjectsOrBuilder { - private static final long serialVersionUID = 0L; - // Use Objects.newBuilder() to construct. - private Objects(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Objects() { - values_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Objects(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List values_; - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - @java.lang.Override - public java.util.List getValuesList() { - return values_; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - @java.lang.Override - public java.util.List - getValuesOrBuilderList() { - return values_; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - @java.lang.Override - public int getValuesCount() { - return values_.size(); - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getValues(int index) { - return values_.get(index); - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder( - int index) { - return values_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - output.writeMessage(1, values_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < values_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, values_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.Objects} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.Objects) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - } else { - values_ = null; - valuesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects result) { - if (valuesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - values_ = java.util.Collections.unmodifiableList(values_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.values_ = values_; - } else { - result.values_ = valuesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects result) { - int from_bitField0_ = bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance()) return this; - if (valuesBuilder_ == null) { - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - } else { - if (!other.values_.isEmpty()) { - if (valuesBuilder_.isEmpty()) { - valuesBuilder_.dispose(); - valuesBuilder_ = null; - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - valuesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getValuesFieldBuilder() : null; - } else { - valuesBuilder_.addAllMessages(other.values_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.parser(), - extensionRegistry); - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(m); - } else { - valuesBuilder_.addMessage(m); - } - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List values_ = - java.util.Collections.emptyList(); - private void ensureValuesIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - values_ = new java.util.ArrayList(values_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder> valuesBuilder_; - - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public java.util.List getValuesList() { - if (valuesBuilder_ == null) { - return java.util.Collections.unmodifiableList(values_); - } else { - return valuesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public int getValuesCount() { - if (valuesBuilder_ == null) { - return values_.size(); - } else { - return valuesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getValues(int index) { - if (valuesBuilder_ == null) { - return values_.get(index); - } else { - return valuesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.set(index, value); - onChanged(); - } else { - valuesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.set(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(value); - onChanged(); - } else { - valuesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(index, value); - onChanged(); - } else { - valuesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder addValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder addAllValues( - java.lang.Iterable values) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - onChanged(); - } else { - valuesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder clearValues() { - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - valuesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public Builder removeValues(int index) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.remove(index); - onChanged(); - } else { - valuesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder getValuesBuilder( - int index) { - return getValuesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder( - int index) { - if (valuesBuilder_ == null) { - return values_.get(index); } else { - return valuesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public java.util.List - getValuesOrBuilderList() { - if (valuesBuilder_ != null) { - return valuesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(values_); - } - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder addValuesBuilder() { - return getValuesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder addValuesBuilder( - int index) { - return getValuesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject values = 1; - */ - public java.util.List - getValuesBuilderList() { - return getValuesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder> - getValuesFieldBuilder() { - if (valuesBuilder_ == null) { - valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder>( - values_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - values_ = null; - } - return valuesBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.Objects) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.Objects) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Objects parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ReferencesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.References) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - java.util.List - getValuesList(); - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getValues(int index); - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - int getValuesCount(); - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - java.util.List - getValuesOrBuilderList(); - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.References} - */ - public static final class References extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.References) - ReferencesOrBuilder { - private static final long serialVersionUID = 0L; - // Use References.newBuilder() to construct. - private References(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private References() { - values_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new References(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List values_; - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - @java.lang.Override - public java.util.List getValuesList() { - return values_; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - @java.lang.Override - public java.util.List - getValuesOrBuilderList() { - return values_; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - @java.lang.Override - public int getValuesCount() { - return values_.size(); - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getValues(int index) { - return values_.get(index); - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder( - int index) { - return values_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - output.writeMessage(1, values_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < values_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, values_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest.References} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.References) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - } else { - values_ = null; - valuesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References result) { - if (valuesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - values_ = java.util.Collections.unmodifiableList(values_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.values_ = values_; - } else { - result.values_ = valuesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References result) { - int from_bitField0_ = bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance()) return this; - if (valuesBuilder_ == null) { - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - } else { - if (!other.values_.isEmpty()) { - if (valuesBuilder_.isEmpty()) { - valuesBuilder_.dispose(); - valuesBuilder_ = null; - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - valuesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getValuesFieldBuilder() : null; - } else { - valuesBuilder_.addAllMessages(other.values_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.parser(), - extensionRegistry); - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(m); - } else { - valuesBuilder_.addMessage(m); - } - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List values_ = - java.util.Collections.emptyList(); - private void ensureValuesIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - values_ = new java.util.ArrayList(values_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder> valuesBuilder_; - - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public java.util.List getValuesList() { - if (valuesBuilder_ == null) { - return java.util.Collections.unmodifiableList(values_); - } else { - return valuesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public int getValuesCount() { - if (valuesBuilder_ == null) { - return values_.size(); - } else { - return valuesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getValues(int index) { - if (valuesBuilder_ == null) { - return values_.get(index); - } else { - return valuesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.set(index, value); - onChanged(); - } else { - valuesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.set(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(value); - onChanged(); - } else { - valuesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(index, value); - onChanged(); - } else { - valuesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder addValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder addAllValues( - java.lang.Iterable values) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - onChanged(); - } else { - valuesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder clearValues() { - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - valuesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public Builder removeValues(int index) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.remove(index); - onChanged(); - } else { - valuesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder getValuesBuilder( - int index) { - return getValuesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder( - int index) { - if (valuesBuilder_ == null) { - return values_.get(index); } else { - return valuesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public java.util.List - getValuesOrBuilderList() { - if (valuesBuilder_ != null) { - return valuesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(values_); - } - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder addValuesBuilder() { - return getValuesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder addValuesBuilder( - int index) { - return getValuesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReference values = 1; - */ - public java.util.List - getValuesBuilderList() { - return getValuesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder> - getValuesFieldBuilder() { - if (valuesBuilder_ == null) { - valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder>( - values_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - values_ = null; - } - return valuesBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.References) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.References) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public References parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private int messageCase_ = 0; - @SuppressWarnings("serial") - private java.lang.Object message_; - public enum MessageCase - implements com.google.protobuf.Internal.EnumLite, - com.google.protobuf.AbstractMessage.InternalOneOfEnum { - OBJECTS(2), - REFERENCES(3), - STOP(4), - MESSAGE_NOT_SET(0); - private final int value; - private MessageCase(int value) { - this.value = value; - } - /** - * @param value The number of the enum to look for. - * @return The enum associated with the given number. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static MessageCase valueOf(int value) { - return forNumber(value); - } - - public static MessageCase forNumber(int value) { - switch (value) { - case 2: return OBJECTS; - case 3: return REFERENCES; - case 4: return STOP; - case 0: return MESSAGE_NOT_SET; - default: return null; - } - } - public int getNumber() { - return this.value; - } - }; - - public MessageCase - getMessageCase() { - return MessageCase.forNumber( - messageCase_); - } - - public static final int STREAM_ID_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object streamId_ = ""; - /** - * string stream_id = 1; - * @return The streamId. - */ - @java.lang.Override - public java.lang.String getStreamId() { - java.lang.Object ref = streamId_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - streamId_ = s; - return s; - } - } - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getStreamIdBytes() { - java.lang.Object ref = streamId_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - streamId_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int OBJECTS_FIELD_NUMBER = 2; - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return Whether the objects field is set. - */ - @java.lang.Override - public boolean hasObjects() { - return messageCase_ == 2; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return The objects. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getObjects() { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder() { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - - public static final int REFERENCES_FIELD_NUMBER = 3; - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return Whether the references field is set. - */ - @java.lang.Override - public boolean hasReferences() { - return messageCase_ == 3; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return The references. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getReferences() { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder() { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - - public static final int STOP_FIELD_NUMBER = 4; - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return Whether the stop field is set. - */ - @java.lang.Override - public boolean hasStop() { - return messageCase_ == 4; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return The stop. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getStop() { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder() { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, streamId_); - } - if (messageCase_ == 2) { - output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_); - } - if (messageCase_ == 3) { - output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_); - } - if (messageCase_ == 4) { - output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, streamId_); - } - if (messageCase_ == 2) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_); - } - if (messageCase_ == 3) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_); - } - if (messageCase_ == 4) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest) obj; - - if (!getStreamId() - .equals(other.getStreamId())) return false; - if (!getMessageCase().equals(other.getMessageCase())) return false; - switch (messageCase_) { - case 2: - if (!getObjects() - .equals(other.getObjects())) return false; - break; - case 3: - if (!getReferences() - .equals(other.getReferences())) return false; - break; - case 4: - if (!getStop() - .equals(other.getStop())) return false; - break; - case 0: - default: - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + STREAM_ID_FIELD_NUMBER; - hash = (53 * hash) + getStreamId().hashCode(); - switch (messageCase_) { - case 2: - hash = (37 * hash) + OBJECTS_FIELD_NUMBER; - hash = (53 * hash) + getObjects().hashCode(); - break; - case 3: - hash = (37 * hash) + REFERENCES_FIELD_NUMBER; - hash = (53 * hash) + getReferences().hashCode(); - break; - case 4: - hash = (37 * hash) + STOP_FIELD_NUMBER; - hash = (53 * hash) + getStop().hashCode(); - break; - case 0: - default: - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchSendRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - streamId_ = ""; - if (objectsBuilder_ != null) { - objectsBuilder_.clear(); - } - if (referencesBuilder_ != null) { - referencesBuilder_.clear(); - } - if (stopBuilder_ != null) { - stopBuilder_.clear(); - } - messageCase_ = 0; - message_ = null; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - buildPartialOneofs(result); - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.streamId_ = streamId_; - } - } - - private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest result) { - result.messageCase_ = messageCase_; - result.message_ = this.message_; - if (messageCase_ == 2 && - objectsBuilder_ != null) { - result.message_ = objectsBuilder_.build(); - } - if (messageCase_ == 3 && - referencesBuilder_ != null) { - result.message_ = referencesBuilder_.build(); - } - if (messageCase_ == 4 && - stopBuilder_ != null) { - result.message_ = stopBuilder_.build(); - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance()) return this; - if (!other.getStreamId().isEmpty()) { - streamId_ = other.streamId_; - bitField0_ |= 0x00000001; - onChanged(); - } - switch (other.getMessageCase()) { - case OBJECTS: { - mergeObjects(other.getObjects()); - break; - } - case REFERENCES: { - mergeReferences(other.getReferences()); - break; - } - case STOP: { - mergeStop(other.getStop()); - break; - } - case MESSAGE_NOT_SET: { - break; - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - streamId_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - input.readMessage( - getObjectsFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 2; - break; - } // case 18 - case 26: { - input.readMessage( - getReferencesFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 3; - break; - } // case 26 - case 34: { - input.readMessage( - getStopFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 4; - break; - } // case 34 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int messageCase_ = 0; - private java.lang.Object message_; - public MessageCase - getMessageCase() { - return MessageCase.forNumber( - messageCase_); - } - - public Builder clearMessage() { - messageCase_ = 0; - message_ = null; - onChanged(); - return this; - } - - private int bitField0_; - - private java.lang.Object streamId_ = ""; - /** - * string stream_id = 1; - * @return The streamId. - */ - public java.lang.String getStreamId() { - java.lang.Object ref = streamId_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - streamId_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - public com.google.protobuf.ByteString - getStreamIdBytes() { - java.lang.Object ref = streamId_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - streamId_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string stream_id = 1; - * @param value The streamId to set. - * @return This builder for chaining. - */ - public Builder setStreamId( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - streamId_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string stream_id = 1; - * @return This builder for chaining. - */ - public Builder clearStreamId() { - streamId_ = getDefaultInstance().getStreamId(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string stream_id = 1; - * @param value The bytes for streamId to set. - * @return This builder for chaining. - */ - public Builder setStreamIdBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - streamId_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder> objectsBuilder_; - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return Whether the objects field is set. - */ - @java.lang.Override - public boolean hasObjects() { - return messageCase_ == 2; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - * @return The objects. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects getObjects() { - if (objectsBuilder_ == null) { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } else { - if (messageCase_ == 2) { - return objectsBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - public Builder setObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - objectsBuilder_.setMessage(value); - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - public Builder setObjects( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder builderForValue) { - if (objectsBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - objectsBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - public Builder mergeObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects value) { - if (objectsBuilder_ == null) { - if (messageCase_ == 2 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 2) { - objectsBuilder_.mergeFrom(value); - } else { - objectsBuilder_.setMessage(value); - } - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - public Builder clearObjects() { - if (objectsBuilder_ == null) { - if (messageCase_ == 2) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 2) { - messageCase_ = 0; - message_ = null; - } - objectsBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder getObjectsBuilder() { - return getObjectsFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder() { - if ((messageCase_ == 2) && (objectsBuilder_ != null)) { - return objectsBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.Objects objects = 2; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder> - getObjectsFieldBuilder() { - if (objectsBuilder_ == null) { - if (!(messageCase_ == 2)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance(); - } - objectsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Objects) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 2; - onChanged(); - return objectsBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder> referencesBuilder_; - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return Whether the references field is set. - */ - @java.lang.Override - public boolean hasReferences() { - return messageCase_ == 3; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - * @return The references. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References getReferences() { - if (referencesBuilder_ == null) { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } else { - if (messageCase_ == 3) { - return referencesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - public Builder setReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References value) { - if (referencesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - referencesBuilder_.setMessage(value); - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - public Builder setReferences( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder builderForValue) { - if (referencesBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - referencesBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - public Builder mergeReferences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References value) { - if (referencesBuilder_ == null) { - if (messageCase_ == 3 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 3) { - referencesBuilder_.mergeFrom(value); - } else { - referencesBuilder_.setMessage(value); - } - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - public Builder clearReferences() { - if (referencesBuilder_ == null) { - if (messageCase_ == 3) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 3) { - messageCase_ = 0; - message_ = null; - } - referencesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder getReferencesBuilder() { - return getReferencesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder() { - if ((messageCase_ == 3) && (referencesBuilder_ != null)) { - return referencesBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.References references = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder> - getReferencesFieldBuilder() { - if (referencesBuilder_ == null) { - if (!(messageCase_ == 3)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance(); - } - referencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.References) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 3; - onChanged(); - return referencesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder> stopBuilder_; - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return Whether the stop field is set. - */ - @java.lang.Override - public boolean hasStop() { - return messageCase_ == 4; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - * @return The stop. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop getStop() { - if (stopBuilder_ == null) { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } else { - if (messageCase_ == 4) { - return stopBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop value) { - if (stopBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - stopBuilder_.setMessage(value); - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - public Builder setStop( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder builderForValue) { - if (stopBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - stopBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - public Builder mergeStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop value) { - if (stopBuilder_ == null) { - if (messageCase_ == 4 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 4) { - stopBuilder_.mergeFrom(value); - } else { - stopBuilder_.setMessage(value); - } - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - public Builder clearStop() { - if (stopBuilder_ == null) { - if (messageCase_ == 4) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 4) { - messageCase_ = 0; - message_ = null; - } - stopBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder getStopBuilder() { - return getStopFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder() { - if ((messageCase_ == 4) && (stopBuilder_ != null)) { - return stopBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchSendRequest.Stop stop = 4; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder> - getStopFieldBuilder() { - if (stopBuilder_ == null) { - if (!(messageCase_ == 4)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance(); - } - stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest.Stop) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 4; - onChanged(); - return stopBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchSendRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchSendReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendReply) - com.google.protobuf.MessageOrBuilder { - - /** - * int32 next_batch_size = 1; - * @return The nextBatchSize. - */ - int getNextBatchSize(); - - /** - * float backoff_seconds = 2; - * @return The backoffSeconds. - */ - float getBackoffSeconds(); - } - /** - * Protobuf type {@code weaviate.v1.BatchSendReply} - */ - public static final class BatchSendReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendReply) - BatchSendReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchSendReply.newBuilder() to construct. - private BatchSendReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchSendReply() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchSendReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.Builder.class); - } - - public static final int NEXT_BATCH_SIZE_FIELD_NUMBER = 1; - private int nextBatchSize_ = 0; - /** - * int32 next_batch_size = 1; - * @return The nextBatchSize. - */ - @java.lang.Override - public int getNextBatchSize() { - return nextBatchSize_; - } - - public static final int BACKOFF_SECONDS_FIELD_NUMBER = 2; - private float backoffSeconds_ = 0F; - /** - * float backoff_seconds = 2; - * @return The backoffSeconds. - */ - @java.lang.Override - public float getBackoffSeconds() { - return backoffSeconds_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (nextBatchSize_ != 0) { - output.writeInt32(1, nextBatchSize_); - } - if (java.lang.Float.floatToRawIntBits(backoffSeconds_) != 0) { - output.writeFloat(2, backoffSeconds_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (nextBatchSize_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(1, nextBatchSize_); - } - if (java.lang.Float.floatToRawIntBits(backoffSeconds_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(2, backoffSeconds_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply) obj; - - if (getNextBatchSize() - != other.getNextBatchSize()) return false; - if (java.lang.Float.floatToIntBits(getBackoffSeconds()) - != java.lang.Float.floatToIntBits( - other.getBackoffSeconds())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + NEXT_BATCH_SIZE_FIELD_NUMBER; - hash = (53 * hash) + getNextBatchSize(); - hash = (37 * hash) + BACKOFF_SECONDS_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getBackoffSeconds()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchSendReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - nextBatchSize_ = 0; - backoffSeconds_ = 0F; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.nextBatchSize_ = nextBatchSize_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.backoffSeconds_ = backoffSeconds_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply.getDefaultInstance()) return this; - if (other.getNextBatchSize() != 0) { - setNextBatchSize(other.getNextBatchSize()); - } - if (other.getBackoffSeconds() != 0F) { - setBackoffSeconds(other.getBackoffSeconds()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - nextBatchSize_ = input.readInt32(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 21: { - backoffSeconds_ = input.readFloat(); - bitField0_ |= 0x00000002; - break; - } // case 21 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private int nextBatchSize_ ; - /** - * int32 next_batch_size = 1; - * @return The nextBatchSize. - */ - @java.lang.Override - public int getNextBatchSize() { - return nextBatchSize_; - } - /** - * int32 next_batch_size = 1; - * @param value The nextBatchSize to set. - * @return This builder for chaining. - */ - public Builder setNextBatchSize(int value) { - - nextBatchSize_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * int32 next_batch_size = 1; - * @return This builder for chaining. - */ - public Builder clearNextBatchSize() { - bitField0_ = (bitField0_ & ~0x00000001); - nextBatchSize_ = 0; - onChanged(); - return this; - } - - private float backoffSeconds_ ; - /** - * float backoff_seconds = 2; - * @return The backoffSeconds. - */ - @java.lang.Override - public float getBackoffSeconds() { - return backoffSeconds_; - } - /** - * float backoff_seconds = 2; - * @param value The backoffSeconds to set. - * @return This builder for chaining. - */ - public Builder setBackoffSeconds(float value) { - - backoffSeconds_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * float backoff_seconds = 2; - * @return This builder for chaining. - */ - public Builder clearBackoffSeconds() { - bitField0_ = (bitField0_ & ~0x00000002); - backoffSeconds_ = 0F; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendReply) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchSendReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchSendReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchStreamRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return Whether the consistencyLevel field is set. - */ - boolean hasConsistencyLevel(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The enum numeric value on the wire for consistencyLevel. - */ - int getConsistencyLevelValue(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The consistencyLevel. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); - - /** - * optional int32 object_index = 2; - * @return Whether the objectIndex field is set. - */ - boolean hasObjectIndex(); - /** - * optional int32 object_index = 2; - * @return The objectIndex. - */ - int getObjectIndex(); - - /** - * optional int32 reference_index = 3; - * @return Whether the referenceIndex field is set. - */ - boolean hasReferenceIndex(); - /** - * optional int32 reference_index = 3; - * @return The referenceIndex. - */ - int getReferenceIndex(); - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamRequest} - */ - public static final class BatchStreamRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamRequest) - BatchStreamRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchStreamRequest.newBuilder() to construct. - private BatchStreamRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchStreamRequest() { - consistencyLevel_ = 0; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchStreamRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.Builder.class); - } - - private int bitField0_; - public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 1; - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The consistencyLevel. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - - public static final int OBJECT_INDEX_FIELD_NUMBER = 2; - private int objectIndex_ = 0; - /** - * optional int32 object_index = 2; - * @return Whether the objectIndex field is set. - */ - @java.lang.Override - public boolean hasObjectIndex() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional int32 object_index = 2; - * @return The objectIndex. - */ - @java.lang.Override - public int getObjectIndex() { - return objectIndex_; - } - - public static final int REFERENCE_INDEX_FIELD_NUMBER = 3; - private int referenceIndex_ = 0; - /** - * optional int32 reference_index = 3; - * @return Whether the referenceIndex field is set. - */ - @java.lang.Override - public boolean hasReferenceIndex() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional int32 reference_index = 3; - * @return The referenceIndex. - */ - @java.lang.Override - public int getReferenceIndex() { - return referenceIndex_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (((bitField0_ & 0x00000001) != 0)) { - output.writeEnum(1, consistencyLevel_); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeInt32(2, objectIndex_); - } - if (((bitField0_ & 0x00000004) != 0)) { - output.writeInt32(3, referenceIndex_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(1, consistencyLevel_); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(2, objectIndex_); - } - if (((bitField0_ & 0x00000004) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(3, referenceIndex_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest) obj; - - if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false; - if (hasConsistencyLevel()) { - if (consistencyLevel_ != other.consistencyLevel_) return false; - } - if (hasObjectIndex() != other.hasObjectIndex()) return false; - if (hasObjectIndex()) { - if (getObjectIndex() - != other.getObjectIndex()) return false; - } - if (hasReferenceIndex() != other.hasReferenceIndex()) return false; - if (hasReferenceIndex()) { - if (getReferenceIndex() - != other.getReferenceIndex()) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (hasConsistencyLevel()) { - hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER; - hash = (53 * hash) + consistencyLevel_; - } - if (hasObjectIndex()) { - hash = (37 * hash) + OBJECT_INDEX_FIELD_NUMBER; - hash = (53 * hash) + getObjectIndex(); - } - if (hasReferenceIndex()) { - hash = (37 * hash) + REFERENCE_INDEX_FIELD_NUMBER; - hash = (53 * hash) + getReferenceIndex(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - consistencyLevel_ = 0; - objectIndex_ = 0; - referenceIndex_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest result) { - int from_bitField0_ = bitField0_; - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.consistencyLevel_ = consistencyLevel_; - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.objectIndex_ = objectIndex_; - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.referenceIndex_ = referenceIndex_; - to_bitField0_ |= 0x00000004; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance()) return this; - if (other.hasConsistencyLevel()) { - setConsistencyLevel(other.getConsistencyLevel()); - } - if (other.hasObjectIndex()) { - setObjectIndex(other.getObjectIndex()); - } - if (other.hasReferenceIndex()) { - setReferenceIndex(other.getReferenceIndex()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - consistencyLevel_ = input.readEnum(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 16: { - objectIndex_ = input.readInt32(); - bitField0_ |= 0x00000002; - break; - } // case 16 - case 24: { - referenceIndex_ = input.readInt32(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @param value The enum numeric value on the wire for consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevelValue(int value) { - consistencyLevel_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return The consistencyLevel. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @param value The consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevel(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000001; - consistencyLevel_ = value.getNumber(); - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 1; - * @return This builder for chaining. - */ - public Builder clearConsistencyLevel() { - bitField0_ = (bitField0_ & ~0x00000001); - consistencyLevel_ = 0; - onChanged(); - return this; - } - - private int objectIndex_ ; - /** - * optional int32 object_index = 2; - * @return Whether the objectIndex field is set. - */ - @java.lang.Override - public boolean hasObjectIndex() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional int32 object_index = 2; - * @return The objectIndex. - */ - @java.lang.Override - public int getObjectIndex() { - return objectIndex_; - } - /** - * optional int32 object_index = 2; - * @param value The objectIndex to set. - * @return This builder for chaining. - */ - public Builder setObjectIndex(int value) { - - objectIndex_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * optional int32 object_index = 2; - * @return This builder for chaining. - */ - public Builder clearObjectIndex() { - bitField0_ = (bitField0_ & ~0x00000002); - objectIndex_ = 0; - onChanged(); - return this; - } - - private int referenceIndex_ ; - /** - * optional int32 reference_index = 3; - * @return Whether the referenceIndex field is set. - */ - @java.lang.Override - public boolean hasReferenceIndex() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional int32 reference_index = 3; - * @return The referenceIndex. - */ - @java.lang.Override - public int getReferenceIndex() { - return referenceIndex_; - } - /** - * optional int32 reference_index = 3; - * @param value The referenceIndex to set. - * @return This builder for chaining. - */ - public Builder setReferenceIndex(int value) { - - referenceIndex_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * optional int32 reference_index = 3; - * @return This builder for chaining. - */ - public Builder clearReferenceIndex() { - bitField0_ = (bitField0_ & ~0x00000004); - referenceIndex_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchStreamRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchStreamMessageOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage) - com.google.protobuf.MessageOrBuilder { - - /** - * string stream_id = 1; - * @return The streamId. - */ - java.lang.String getStreamId(); - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - com.google.protobuf.ByteString - getStreamIdBytes(); - - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return Whether the error field is set. - */ - boolean hasError(); - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return The error. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getError(); - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder(); - - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return Whether the start field is set. - */ - boolean hasStart(); - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return The start. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getStart(); - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder(); - - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return Whether the stop field is set. - */ - boolean hasStop(); - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return The stop. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getStop(); - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder(); - - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return Whether the shutdown field is set. - */ - boolean hasShutdown(); - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return The shutdown. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown(); - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder(); - - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return Whether the shuttingDown field is set. - */ - boolean hasShuttingDown(); - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return The shuttingDown. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown(); - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder(); - - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.MessageCase getMessageCase(); - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage} - */ - public static final class BatchStreamMessage extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage) - BatchStreamMessageOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchStreamMessage.newBuilder() to construct. - private BatchStreamMessage(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchStreamMessage() { - streamId_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchStreamMessage(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Builder.class); - } - - public interface StartOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Start) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Start} - */ - public static final class Start extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Start) - StartOrBuilder { - private static final long serialVersionUID = 0L; - // Use Start.newBuilder() to construct. - private Start(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Start() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Start(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Start} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Start) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Start) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Start) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Start parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface StopOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Stop) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Stop} - */ - public static final class Stop extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Stop) - StopOrBuilder { - private static final long serialVersionUID = 0L; - // Use Stop.newBuilder() to construct. - private Stop(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Stop() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Stop(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Stop} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Stop) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Stop) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Stop) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Stop parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ShutdownOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Shutdown) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Shutdown} - */ - public static final class Shutdown extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Shutdown) - ShutdownOrBuilder { - private static final long serialVersionUID = 0L; - // Use Shutdown.newBuilder() to construct. - private Shutdown(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Shutdown() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Shutdown(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Shutdown} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Shutdown) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Shutdown) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Shutdown) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Shutdown parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ShuttingDownOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.ShuttingDown) - com.google.protobuf.MessageOrBuilder { - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.ShuttingDown} - */ - public static final class ShuttingDown extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.ShuttingDown) - ShuttingDownOrBuilder { - private static final long serialVersionUID = 0L; - // Use ShuttingDown.newBuilder() to construct. - private ShuttingDown(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ShuttingDown() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ShuttingDown(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder.class); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) obj; - - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.ShuttingDown} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.ShuttingDown) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown(this); - onBuilt(); - return result; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance()) return this; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.ShuttingDown) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.ShuttingDown) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ShuttingDown parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ErrorOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Error) - com.google.protobuf.MessageOrBuilder { - - /** - * string error = 1; - * @return The error. - */ - java.lang.String getError(); - /** - * string error = 1; - * @return The bytes for error. - */ - com.google.protobuf.ByteString - getErrorBytes(); - - /** - * int32 index = 2; - * @return The index. - */ - int getIndex(); - - /** - * bool is_retriable = 3; - * @return The isRetriable. - */ - boolean getIsRetriable(); - - /** - * bool is_object = 4; - * @return The isObject. - */ - boolean getIsObject(); - - /** - * bool is_reference = 5; - * @return The isReference. - */ - boolean getIsReference(); - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Error} - */ - public static final class Error extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Error) - ErrorOrBuilder { - private static final long serialVersionUID = 0L; - // Use Error.newBuilder() to construct. - private Error(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Error() { - error_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Error(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder.class); - } - - public static final int ERROR_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object error_ = ""; - /** - * string error = 1; - * @return The error. - */ - @java.lang.Override - public java.lang.String getError() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } - } - /** - * string error = 1; - * @return The bytes for error. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int INDEX_FIELD_NUMBER = 2; - private int index_ = 0; - /** - * int32 index = 2; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - - public static final int IS_RETRIABLE_FIELD_NUMBER = 3; - private boolean isRetriable_ = false; - /** - * bool is_retriable = 3; - * @return The isRetriable. - */ - @java.lang.Override - public boolean getIsRetriable() { - return isRetriable_; - } - - public static final int IS_OBJECT_FIELD_NUMBER = 4; - private boolean isObject_ = false; - /** - * bool is_object = 4; - * @return The isObject. - */ - @java.lang.Override - public boolean getIsObject() { - return isObject_; - } - - public static final int IS_REFERENCE_FIELD_NUMBER = 5; - private boolean isReference_ = false; - /** - * bool is_reference = 5; - * @return The isReference. - */ - @java.lang.Override - public boolean getIsReference() { - return isReference_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, error_); - } - if (index_ != 0) { - output.writeInt32(2, index_); - } - if (isRetriable_ != false) { - output.writeBool(3, isRetriable_); - } - if (isObject_ != false) { - output.writeBool(4, isObject_); - } - if (isReference_ != false) { - output.writeBool(5, isReference_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, error_); - } - if (index_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(2, index_); - } - if (isRetriable_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(3, isRetriable_); - } - if (isObject_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(4, isObject_); - } - if (isReference_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(5, isReference_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) obj; - - if (!getError() - .equals(other.getError())) return false; - if (getIndex() - != other.getIndex()) return false; - if (getIsRetriable() - != other.getIsRetriable()) return false; - if (getIsObject() - != other.getIsObject()) return false; - if (getIsReference() - != other.getIsReference()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + ERROR_FIELD_NUMBER; - hash = (53 * hash) + getError().hashCode(); - hash = (37 * hash) + INDEX_FIELD_NUMBER; - hash = (53 * hash) + getIndex(); - hash = (37 * hash) + IS_RETRIABLE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsRetriable()); - hash = (37 * hash) + IS_OBJECT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsObject()); - hash = (37 * hash) + IS_REFERENCE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsReference()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage.Error} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Error) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - error_ = ""; - index_ = 0; - isRetriable_ = false; - isObject_ = false; - isReference_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.error_ = error_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.index_ = index_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.isRetriable_ = isRetriable_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.isObject_ = isObject_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.isReference_ = isReference_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance()) return this; - if (!other.getError().isEmpty()) { - error_ = other.error_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (other.getIndex() != 0) { - setIndex(other.getIndex()); - } - if (other.getIsRetriable() != false) { - setIsRetriable(other.getIsRetriable()); - } - if (other.getIsObject() != false) { - setIsObject(other.getIsObject()); - } - if (other.getIsReference() != false) { - setIsReference(other.getIsReference()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - error_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 16: { - index_ = input.readInt32(); - bitField0_ |= 0x00000002; - break; - } // case 16 - case 24: { - isRetriable_ = input.readBool(); - bitField0_ |= 0x00000004; - break; - } // case 24 - case 32: { - isObject_ = input.readBool(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 40: { - isReference_ = input.readBool(); - bitField0_ |= 0x00000010; - break; - } // case 40 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object error_ = ""; - /** - * string error = 1; - * @return The error. - */ - public java.lang.String getError() { - java.lang.Object ref = error_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string error = 1; - * @return The bytes for error. - */ - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string error = 1; - * @param value The error to set. - * @return This builder for chaining. - */ - public Builder setError( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - error_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string error = 1; - * @return This builder for chaining. - */ - public Builder clearError() { - error_ = getDefaultInstance().getError(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string error = 1; - * @param value The bytes for error to set. - * @return This builder for chaining. - */ - public Builder setErrorBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - error_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private int index_ ; - /** - * int32 index = 2; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - /** - * int32 index = 2; - * @param value The index to set. - * @return This builder for chaining. - */ - public Builder setIndex(int value) { - - index_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * int32 index = 2; - * @return This builder for chaining. - */ - public Builder clearIndex() { - bitField0_ = (bitField0_ & ~0x00000002); - index_ = 0; - onChanged(); - return this; - } - - private boolean isRetriable_ ; - /** - * bool is_retriable = 3; - * @return The isRetriable. - */ - @java.lang.Override - public boolean getIsRetriable() { - return isRetriable_; - } - /** - * bool is_retriable = 3; - * @param value The isRetriable to set. - * @return This builder for chaining. - */ - public Builder setIsRetriable(boolean value) { - - isRetriable_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * bool is_retriable = 3; - * @return This builder for chaining. - */ - public Builder clearIsRetriable() { - bitField0_ = (bitField0_ & ~0x00000004); - isRetriable_ = false; - onChanged(); - return this; - } - - private boolean isObject_ ; - /** - * bool is_object = 4; - * @return The isObject. - */ - @java.lang.Override - public boolean getIsObject() { - return isObject_; - } - /** - * bool is_object = 4; - * @param value The isObject to set. - * @return This builder for chaining. - */ - public Builder setIsObject(boolean value) { - - isObject_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * bool is_object = 4; - * @return This builder for chaining. - */ - public Builder clearIsObject() { - bitField0_ = (bitField0_ & ~0x00000008); - isObject_ = false; - onChanged(); - return this; - } - - private boolean isReference_ ; - /** - * bool is_reference = 5; - * @return The isReference. - */ - @java.lang.Override - public boolean getIsReference() { - return isReference_; - } - /** - * bool is_reference = 5; - * @param value The isReference to set. - * @return This builder for chaining. - */ - public Builder setIsReference(boolean value) { - - isReference_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * bool is_reference = 5; - * @return This builder for chaining. - */ - public Builder clearIsReference() { - bitField0_ = (bitField0_ & ~0x00000010); - isReference_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Error) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Error) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Error parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private int messageCase_ = 0; - @SuppressWarnings("serial") - private java.lang.Object message_; - public enum MessageCase - implements com.google.protobuf.Internal.EnumLite, - com.google.protobuf.AbstractMessage.InternalOneOfEnum { - ERROR(2), - START(3), - STOP(4), - SHUTDOWN(5), - SHUTTING_DOWN(6), - MESSAGE_NOT_SET(0); - private final int value; - private MessageCase(int value) { - this.value = value; - } - /** - * @param value The number of the enum to look for. - * @return The enum associated with the given number. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static MessageCase valueOf(int value) { - return forNumber(value); - } - - public static MessageCase forNumber(int value) { - switch (value) { - case 2: return ERROR; - case 3: return START; - case 4: return STOP; - case 5: return SHUTDOWN; - case 6: return SHUTTING_DOWN; - case 0: return MESSAGE_NOT_SET; - default: return null; - } - } - public int getNumber() { - return this.value; - } - }; - - public MessageCase - getMessageCase() { - return MessageCase.forNumber( - messageCase_); - } - - public static final int STREAM_ID_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object streamId_ = ""; - /** - * string stream_id = 1; - * @return The streamId. - */ - @java.lang.Override - public java.lang.String getStreamId() { - java.lang.Object ref = streamId_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - streamId_ = s; - return s; - } - } - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getStreamIdBytes() { - java.lang.Object ref = streamId_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - streamId_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int ERROR_FIELD_NUMBER = 2; - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return Whether the error field is set. - */ - @java.lang.Override - public boolean hasError() { - return messageCase_ == 2; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return The error. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getError() { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder() { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - - public static final int START_FIELD_NUMBER = 3; - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return Whether the start field is set. - */ - @java.lang.Override - public boolean hasStart() { - return messageCase_ == 3; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return The start. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getStart() { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder() { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - - public static final int STOP_FIELD_NUMBER = 4; - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return Whether the stop field is set. - */ - @java.lang.Override - public boolean hasStop() { - return messageCase_ == 4; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return The stop. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getStop() { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder() { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - - public static final int SHUTDOWN_FIELD_NUMBER = 5; - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return Whether the shutdown field is set. - */ - @java.lang.Override - public boolean hasShutdown() { - return messageCase_ == 5; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return The shutdown. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown() { - if (messageCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder() { - if (messageCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - - public static final int SHUTTING_DOWN_FIELD_NUMBER = 6; - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return Whether the shuttingDown field is set. - */ - @java.lang.Override - public boolean hasShuttingDown() { - return messageCase_ == 6; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return The shuttingDown. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown() { - if (messageCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder() { - if (messageCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, streamId_); - } - if (messageCase_ == 2) { - output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_); - } - if (messageCase_ == 3) { - output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_); - } - if (messageCase_ == 4) { - output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_); - } - if (messageCase_ == 5) { - output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_); - } - if (messageCase_ == 6) { - output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, streamId_); - } - if (messageCase_ == 2) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_); - } - if (messageCase_ == 3) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_); - } - if (messageCase_ == 4) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_); - } - if (messageCase_ == 5) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_); - } - if (messageCase_ == 6) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage) obj; - - if (!getStreamId() - .equals(other.getStreamId())) return false; - if (!getMessageCase().equals(other.getMessageCase())) return false; - switch (messageCase_) { - case 2: - if (!getError() - .equals(other.getError())) return false; - break; - case 3: - if (!getStart() - .equals(other.getStart())) return false; - break; - case 4: - if (!getStop() - .equals(other.getStop())) return false; - break; - case 5: - if (!getShutdown() - .equals(other.getShutdown())) return false; - break; - case 6: - if (!getShuttingDown() - .equals(other.getShuttingDown())) return false; - break; - case 0: - default: - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + STREAM_ID_FIELD_NUMBER; - hash = (53 * hash) + getStreamId().hashCode(); - switch (messageCase_) { - case 2: - hash = (37 * hash) + ERROR_FIELD_NUMBER; - hash = (53 * hash) + getError().hashCode(); - break; - case 3: - hash = (37 * hash) + START_FIELD_NUMBER; - hash = (53 * hash) + getStart().hashCode(); - break; - case 4: - hash = (37 * hash) + STOP_FIELD_NUMBER; - hash = (53 * hash) + getStop().hashCode(); - break; - case 5: - hash = (37 * hash) + SHUTDOWN_FIELD_NUMBER; - hash = (53 * hash) + getShutdown().hashCode(); - break; - case 6: - hash = (37 * hash) + SHUTTING_DOWN_FIELD_NUMBER; - hash = (53 * hash) + getShuttingDown().hashCode(); - break; - case 0: - default: - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchStreamMessage} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessageOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - streamId_ = ""; - if (errorBuilder_ != null) { - errorBuilder_.clear(); - } - if (startBuilder_ != null) { - startBuilder_.clear(); - } - if (stopBuilder_ != null) { - stopBuilder_.clear(); - } - if (shutdownBuilder_ != null) { - shutdownBuilder_.clear(); - } - if (shuttingDownBuilder_ != null) { - shuttingDownBuilder_.clear(); - } - messageCase_ = 0; - message_ = null; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage(this); - if (bitField0_ != 0) { buildPartial0(result); } - buildPartialOneofs(result); - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.streamId_ = streamId_; - } - } - - private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage result) { - result.messageCase_ = messageCase_; - result.message_ = this.message_; - if (messageCase_ == 2 && - errorBuilder_ != null) { - result.message_ = errorBuilder_.build(); - } - if (messageCase_ == 3 && - startBuilder_ != null) { - result.message_ = startBuilder_.build(); - } - if (messageCase_ == 4 && - stopBuilder_ != null) { - result.message_ = stopBuilder_.build(); - } - if (messageCase_ == 5 && - shutdownBuilder_ != null) { - result.message_ = shutdownBuilder_.build(); - } - if (messageCase_ == 6 && - shuttingDownBuilder_ != null) { - result.message_ = shuttingDownBuilder_.build(); - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance()) return this; - if (!other.getStreamId().isEmpty()) { - streamId_ = other.streamId_; - bitField0_ |= 0x00000001; - onChanged(); - } - switch (other.getMessageCase()) { - case ERROR: { - mergeError(other.getError()); - break; - } - case START: { - mergeStart(other.getStart()); - break; - } - case STOP: { - mergeStop(other.getStop()); - break; - } - case SHUTDOWN: { - mergeShutdown(other.getShutdown()); - break; - } - case SHUTTING_DOWN: { - mergeShuttingDown(other.getShuttingDown()); - break; - } - case MESSAGE_NOT_SET: { - break; - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - streamId_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - input.readMessage( - getErrorFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 2; - break; - } // case 18 - case 26: { - input.readMessage( - getStartFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 3; - break; - } // case 26 - case 34: { - input.readMessage( - getStopFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 4; - break; - } // case 34 - case 42: { - input.readMessage( - getShutdownFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 5; - break; - } // case 42 - case 50: { - input.readMessage( - getShuttingDownFieldBuilder().getBuilder(), - extensionRegistry); - messageCase_ = 6; - break; - } // case 50 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int messageCase_ = 0; - private java.lang.Object message_; - public MessageCase - getMessageCase() { - return MessageCase.forNumber( - messageCase_); - } - - public Builder clearMessage() { - messageCase_ = 0; - message_ = null; - onChanged(); - return this; - } - - private int bitField0_; - - private java.lang.Object streamId_ = ""; - /** - * string stream_id = 1; - * @return The streamId. - */ - public java.lang.String getStreamId() { - java.lang.Object ref = streamId_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - streamId_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string stream_id = 1; - * @return The bytes for streamId. - */ - public com.google.protobuf.ByteString - getStreamIdBytes() { - java.lang.Object ref = streamId_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - streamId_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string stream_id = 1; - * @param value The streamId to set. - * @return This builder for chaining. - */ - public Builder setStreamId( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - streamId_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string stream_id = 1; - * @return This builder for chaining. - */ - public Builder clearStreamId() { - streamId_ = getDefaultInstance().getStreamId(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string stream_id = 1; - * @param value The bytes for streamId to set. - * @return This builder for chaining. - */ - public Builder setStreamIdBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - streamId_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder> errorBuilder_; - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return Whether the error field is set. - */ - @java.lang.Override - public boolean hasError() { - return messageCase_ == 2; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - * @return The error. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error getError() { - if (errorBuilder_ == null) { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } else { - if (messageCase_ == 2) { - return errorBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - public Builder setError(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error value) { - if (errorBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - errorBuilder_.setMessage(value); - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - public Builder setError( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder builderForValue) { - if (errorBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - errorBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - public Builder mergeError(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error value) { - if (errorBuilder_ == null) { - if (messageCase_ == 2 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 2) { - errorBuilder_.mergeFrom(value); - } else { - errorBuilder_.setMessage(value); - } - } - messageCase_ = 2; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - public Builder clearError() { - if (errorBuilder_ == null) { - if (messageCase_ == 2) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 2) { - messageCase_ = 0; - message_ = null; - } - errorBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder getErrorBuilder() { - return getErrorFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder() { - if ((messageCase_ == 2) && (errorBuilder_ != null)) { - return errorBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Error error = 2; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder> - getErrorFieldBuilder() { - if (errorBuilder_ == null) { - if (!(messageCase_ == 2)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance(); - } - errorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Error) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 2; - onChanged(); - return errorBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder> startBuilder_; - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return Whether the start field is set. - */ - @java.lang.Override - public boolean hasStart() { - return messageCase_ == 3; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - * @return The start. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start getStart() { - if (startBuilder_ == null) { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } else { - if (messageCase_ == 3) { - return startBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - public Builder setStart(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start value) { - if (startBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - startBuilder_.setMessage(value); - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - public Builder setStart( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder builderForValue) { - if (startBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - startBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - public Builder mergeStart(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start value) { - if (startBuilder_ == null) { - if (messageCase_ == 3 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 3) { - startBuilder_.mergeFrom(value); - } else { - startBuilder_.setMessage(value); - } - } - messageCase_ = 3; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - public Builder clearStart() { - if (startBuilder_ == null) { - if (messageCase_ == 3) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 3) { - messageCase_ = 0; - message_ = null; - } - startBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder getStartBuilder() { - return getStartFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder() { - if ((messageCase_ == 3) && (startBuilder_ != null)) { - return startBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Start start = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder> - getStartFieldBuilder() { - if (startBuilder_ == null) { - if (!(messageCase_ == 3)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance(); - } - startBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Start) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 3; - onChanged(); - return startBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder> stopBuilder_; - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return Whether the stop field is set. - */ - @java.lang.Override - public boolean hasStop() { - return messageCase_ == 4; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - * @return The stop. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop getStop() { - if (stopBuilder_ == null) { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } else { - if (messageCase_ == 4) { - return stopBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop value) { - if (stopBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - stopBuilder_.setMessage(value); - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - public Builder setStop( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder builderForValue) { - if (stopBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - stopBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - public Builder mergeStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop value) { - if (stopBuilder_ == null) { - if (messageCase_ == 4 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 4) { - stopBuilder_.mergeFrom(value); - } else { - stopBuilder_.setMessage(value); - } - } - messageCase_ = 4; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - public Builder clearStop() { - if (stopBuilder_ == null) { - if (messageCase_ == 4) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 4) { - messageCase_ = 0; - message_ = null; - } - stopBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder getStopBuilder() { - return getStopFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder() { - if ((messageCase_ == 4) && (stopBuilder_ != null)) { - return stopBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Stop stop = 4; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder> - getStopFieldBuilder() { - if (stopBuilder_ == null) { - if (!(messageCase_ == 4)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance(); - } - stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Stop) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 4; - onChanged(); - return stopBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder> shutdownBuilder_; - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return Whether the shutdown field is set. - */ - @java.lang.Override - public boolean hasShutdown() { - return messageCase_ == 5; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - * @return The shutdown. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown() { - if (shutdownBuilder_ == null) { - if (messageCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } else { - if (messageCase_ == 5) { - return shutdownBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - public Builder setShutdown(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown value) { - if (shutdownBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - shutdownBuilder_.setMessage(value); - } - messageCase_ = 5; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - public Builder setShutdown( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder builderForValue) { - if (shutdownBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - shutdownBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 5; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - public Builder mergeShutdown(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown value) { - if (shutdownBuilder_ == null) { - if (messageCase_ == 5 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 5) { - shutdownBuilder_.mergeFrom(value); - } else { - shutdownBuilder_.setMessage(value); - } - } - messageCase_ = 5; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - public Builder clearShutdown() { - if (shutdownBuilder_ == null) { - if (messageCase_ == 5) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 5) { - messageCase_ = 0; - message_ = null; - } - shutdownBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder getShutdownBuilder() { - return getShutdownFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder() { - if ((messageCase_ == 5) && (shutdownBuilder_ != null)) { - return shutdownBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder> - getShutdownFieldBuilder() { - if (shutdownBuilder_ == null) { - if (!(messageCase_ == 5)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance(); - } - shutdownBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 5; - onChanged(); - return shutdownBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder> shuttingDownBuilder_; - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return Whether the shuttingDown field is set. - */ - @java.lang.Override - public boolean hasShuttingDown() { - return messageCase_ == 6; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - * @return The shuttingDown. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown() { - if (shuttingDownBuilder_ == null) { - if (messageCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } else { - if (messageCase_ == 6) { - return shuttingDownBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - public Builder setShuttingDown(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown value) { - if (shuttingDownBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - message_ = value; - onChanged(); - } else { - shuttingDownBuilder_.setMessage(value); - } - messageCase_ = 6; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - public Builder setShuttingDown( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder builderForValue) { - if (shuttingDownBuilder_ == null) { - message_ = builderForValue.build(); - onChanged(); - } else { - shuttingDownBuilder_.setMessage(builderForValue.build()); - } - messageCase_ = 6; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - public Builder mergeShuttingDown(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown value) { - if (shuttingDownBuilder_ == null) { - if (messageCase_ == 6 && - message_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance()) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_) - .mergeFrom(value).buildPartial(); - } else { - message_ = value; - } - onChanged(); - } else { - if (messageCase_ == 6) { - shuttingDownBuilder_.mergeFrom(value); - } else { - shuttingDownBuilder_.setMessage(value); - } - } - messageCase_ = 6; - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - public Builder clearShuttingDown() { - if (shuttingDownBuilder_ == null) { - if (messageCase_ == 6) { - messageCase_ = 0; - message_ = null; - onChanged(); - } - } else { - if (messageCase_ == 6) { - messageCase_ = 0; - message_ = null; - } - shuttingDownBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder getShuttingDownBuilder() { - return getShuttingDownFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder() { - if ((messageCase_ == 6) && (shuttingDownBuilder_ != null)) { - return shuttingDownBuilder_.getMessageOrBuilder(); - } else { - if (messageCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder> - getShuttingDownFieldBuilder() { - if (shuttingDownBuilder_ == null) { - if (!(messageCase_ == 6)) { - message_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance(); - } - shuttingDownBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_, - getParentForChildren(), - isClean()); - message_ = null; - } - messageCase_ = 6; - onChanged(); - return shuttingDownBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchStreamMessage parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchStreamMessage getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchObjectOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject) - com.google.protobuf.MessageOrBuilder { - - /** - * string uuid = 1; - * @return The uuid. - */ - java.lang.String getUuid(); - /** - * string uuid = 1; - * @return The bytes for uuid. - */ - com.google.protobuf.ByteString - getUuidBytes(); - - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return A list containing the vector. - */ - @java.lang.Deprecated java.util.List getVectorList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return The count of vector. - */ - @java.lang.Deprecated int getVectorCount(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated float getVector(int index); - - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return Whether the properties field is set. - */ - boolean hasProperties(); - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return The properties. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getProperties(); - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder(); - - /** - * string collection = 4; - * @return The collection. - */ - java.lang.String getCollection(); - /** - * string collection = 4; - * @return The bytes for collection. - */ - com.google.protobuf.ByteString - getCollectionBytes(); - - /** - * string tenant = 5; - * @return The tenant. - */ - java.lang.String getTenant(); - /** - * string tenant = 5; - * @return The bytes for tenant. - */ - com.google.protobuf.ByteString - getTenantBytes(); - - /** - * bytes vector_bytes = 6; - * @return The vectorBytes. - */ - com.google.protobuf.ByteString getVectorBytes(); - - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - java.util.List - getVectorsList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - int getVectorsCount(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - java.util.List - getVectorsOrBuilderList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchObject} - */ - public static final class BatchObject extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject) - BatchObjectOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchObject.newBuilder() to construct. - private BatchObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchObject() { - uuid_ = ""; - vector_ = emptyFloatList(); - collection_ = ""; - tenant_ = ""; - vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - vectors_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchObject(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder.class); - } - - public interface PropertiesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.Properties) - com.google.protobuf.MessageOrBuilder { - - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return Whether the nonRefProperties field is set. - */ - boolean hasNonRefProperties(); - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return The nonRefProperties. - */ - com.google.protobuf.Struct getNonRefProperties(); - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder(); - - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - java.util.List - getSingleTargetRefPropsList(); - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index); - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - int getSingleTargetRefPropsCount(); - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - java.util.List - getSingleTargetRefPropsOrBuilderList(); - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( - int index); - - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - java.util.List - getMultiTargetRefPropsList(); - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index); - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - int getMultiTargetRefPropsCount(); - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - java.util.List - getMultiTargetRefPropsOrBuilderList(); - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( - int index); - - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - java.util.List - getNumberArrayPropertiesList(); - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index); - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - int getNumberArrayPropertiesCount(); - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - java.util.List - getNumberArrayPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - java.util.List - getIntArrayPropertiesList(); - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index); - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - int getIntArrayPropertiesCount(); - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - java.util.List - getIntArrayPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - java.util.List - getTextArrayPropertiesList(); - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index); - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - int getTextArrayPropertiesCount(); - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - java.util.List - getTextArrayPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - java.util.List - getBooleanArrayPropertiesList(); - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index); - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - int getBooleanArrayPropertiesCount(); - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - java.util.List - getBooleanArrayPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - java.util.List - getObjectPropertiesList(); - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index); - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - int getObjectPropertiesCount(); - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - java.util.List - getObjectPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - java.util.List - getObjectArrayPropertiesList(); - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index); - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - int getObjectArrayPropertiesCount(); - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - java.util.List - getObjectArrayPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( - int index); - - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @return A list containing the emptyListProps. - */ - java.util.List - getEmptyListPropsList(); - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @return The count of emptyListProps. - */ - int getEmptyListPropsCount(); - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the element to return. - * @return The emptyListProps at the given index. - */ - java.lang.String getEmptyListProps(int index); - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the value to return. - * @return The bytes of the emptyListProps at the given index. - */ - com.google.protobuf.ByteString - getEmptyListPropsBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.Properties} - */ - public static final class Properties extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.Properties) - PropertiesOrBuilder { - private static final long serialVersionUID = 0L; - // Use Properties.newBuilder() to construct. - private Properties(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Properties() { - singleTargetRefProps_ = java.util.Collections.emptyList(); - multiTargetRefProps_ = java.util.Collections.emptyList(); - numberArrayProperties_ = java.util.Collections.emptyList(); - intArrayProperties_ = java.util.Collections.emptyList(); - textArrayProperties_ = java.util.Collections.emptyList(); - booleanArrayProperties_ = java.util.Collections.emptyList(); - objectProperties_ = java.util.Collections.emptyList(); - objectArrayProperties_ = java.util.Collections.emptyList(); - emptyListProps_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Properties(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder.class); - } - - private int bitField0_; - public static final int NON_REF_PROPERTIES_FIELD_NUMBER = 1; - private com.google.protobuf.Struct nonRefProperties_; - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return Whether the nonRefProperties field is set. - */ - @java.lang.Override - public boolean hasNonRefProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return The nonRefProperties. - */ - @java.lang.Override - public com.google.protobuf.Struct getNonRefProperties() { - return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - @java.lang.Override - public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() { - return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; - } - - public static final int SINGLE_TARGET_REF_PROPS_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List singleTargetRefProps_; - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - @java.lang.Override - public java.util.List getSingleTargetRefPropsList() { - return singleTargetRefProps_; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - @java.lang.Override - public java.util.List - getSingleTargetRefPropsOrBuilderList() { - return singleTargetRefProps_; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - @java.lang.Override - public int getSingleTargetRefPropsCount() { - return singleTargetRefProps_.size(); - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index) { - return singleTargetRefProps_.get(index); - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( - int index) { - return singleTargetRefProps_.get(index); - } - - public static final int MULTI_TARGET_REF_PROPS_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private java.util.List multiTargetRefProps_; - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - @java.lang.Override - public java.util.List getMultiTargetRefPropsList() { - return multiTargetRefProps_; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - @java.lang.Override - public java.util.List - getMultiTargetRefPropsOrBuilderList() { - return multiTargetRefProps_; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - @java.lang.Override - public int getMultiTargetRefPropsCount() { - return multiTargetRefProps_.size(); - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index) { - return multiTargetRefProps_.get(index); - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( - int index) { - return multiTargetRefProps_.get(index); - } - - public static final int NUMBER_ARRAY_PROPERTIES_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private java.util.List numberArrayProperties_; - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - @java.lang.Override - public java.util.List getNumberArrayPropertiesList() { - return numberArrayProperties_; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - @java.lang.Override - public java.util.List - getNumberArrayPropertiesOrBuilderList() { - return numberArrayProperties_; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - @java.lang.Override - public int getNumberArrayPropertiesCount() { - return numberArrayProperties_.size(); - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) { - return numberArrayProperties_.get(index); - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( - int index) { - return numberArrayProperties_.get(index); - } - - public static final int INT_ARRAY_PROPERTIES_FIELD_NUMBER = 5; - @SuppressWarnings("serial") - private java.util.List intArrayProperties_; - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - @java.lang.Override - public java.util.List getIntArrayPropertiesList() { - return intArrayProperties_; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - @java.lang.Override - public java.util.List - getIntArrayPropertiesOrBuilderList() { - return intArrayProperties_; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - @java.lang.Override - public int getIntArrayPropertiesCount() { - return intArrayProperties_.size(); - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) { - return intArrayProperties_.get(index); - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( - int index) { - return intArrayProperties_.get(index); - } - - public static final int TEXT_ARRAY_PROPERTIES_FIELD_NUMBER = 6; - @SuppressWarnings("serial") - private java.util.List textArrayProperties_; - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - @java.lang.Override - public java.util.List getTextArrayPropertiesList() { - return textArrayProperties_; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - @java.lang.Override - public java.util.List - getTextArrayPropertiesOrBuilderList() { - return textArrayProperties_; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - @java.lang.Override - public int getTextArrayPropertiesCount() { - return textArrayProperties_.size(); - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) { - return textArrayProperties_.get(index); - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( - int index) { - return textArrayProperties_.get(index); - } - - public static final int BOOLEAN_ARRAY_PROPERTIES_FIELD_NUMBER = 7; - @SuppressWarnings("serial") - private java.util.List booleanArrayProperties_; - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - @java.lang.Override - public java.util.List getBooleanArrayPropertiesList() { - return booleanArrayProperties_; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - @java.lang.Override - public java.util.List - getBooleanArrayPropertiesOrBuilderList() { - return booleanArrayProperties_; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - @java.lang.Override - public int getBooleanArrayPropertiesCount() { - return booleanArrayProperties_.size(); - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) { - return booleanArrayProperties_.get(index); - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( - int index) { - return booleanArrayProperties_.get(index); - } - - public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 8; - @SuppressWarnings("serial") - private java.util.List objectProperties_; - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - @java.lang.Override - public java.util.List getObjectPropertiesList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - @java.lang.Override - public java.util.List - getObjectPropertiesOrBuilderList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - @java.lang.Override - public int getObjectPropertiesCount() { - return objectProperties_.size(); - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) { - return objectProperties_.get(index); - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( - int index) { - return objectProperties_.get(index); - } - - public static final int OBJECT_ARRAY_PROPERTIES_FIELD_NUMBER = 9; - @SuppressWarnings("serial") - private java.util.List objectArrayProperties_; - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - @java.lang.Override - public java.util.List getObjectArrayPropertiesList() { - return objectArrayProperties_; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - @java.lang.Override - public java.util.List - getObjectArrayPropertiesOrBuilderList() { - return objectArrayProperties_; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - @java.lang.Override - public int getObjectArrayPropertiesCount() { - return objectArrayProperties_.size(); - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) { - return objectArrayProperties_.get(index); - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( - int index) { - return objectArrayProperties_.get(index); - } - - public static final int EMPTY_LIST_PROPS_FIELD_NUMBER = 10; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList emptyListProps_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @return A list containing the emptyListProps. - */ - public com.google.protobuf.ProtocolStringList - getEmptyListPropsList() { - return emptyListProps_; - } - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @return The count of emptyListProps. - */ - public int getEmptyListPropsCount() { - return emptyListProps_.size(); - } - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the element to return. - * @return The emptyListProps at the given index. - */ - public java.lang.String getEmptyListProps(int index) { - return emptyListProps_.get(index); - } - /** - *
-       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-       * Weaviate can get the datatype from its schema
-       * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the value to return. - * @return The bytes of the emptyListProps at the given index. - */ - public com.google.protobuf.ByteString - getEmptyListPropsBytes(int index) { - return emptyListProps_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(1, getNonRefProperties()); - } - for (int i = 0; i < singleTargetRefProps_.size(); i++) { - output.writeMessage(2, singleTargetRefProps_.get(i)); - } - for (int i = 0; i < multiTargetRefProps_.size(); i++) { - output.writeMessage(3, multiTargetRefProps_.get(i)); - } - for (int i = 0; i < numberArrayProperties_.size(); i++) { - output.writeMessage(4, numberArrayProperties_.get(i)); - } - for (int i = 0; i < intArrayProperties_.size(); i++) { - output.writeMessage(5, intArrayProperties_.get(i)); - } - for (int i = 0; i < textArrayProperties_.size(); i++) { - output.writeMessage(6, textArrayProperties_.get(i)); - } - for (int i = 0; i < booleanArrayProperties_.size(); i++) { - output.writeMessage(7, booleanArrayProperties_.get(i)); - } - for (int i = 0; i < objectProperties_.size(); i++) { - output.writeMessage(8, objectProperties_.get(i)); - } - for (int i = 0; i < objectArrayProperties_.size(); i++) { - output.writeMessage(9, objectArrayProperties_.get(i)); - } - for (int i = 0; i < emptyListProps_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 10, emptyListProps_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, getNonRefProperties()); - } - for (int i = 0; i < singleTargetRefProps_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, singleTargetRefProps_.get(i)); - } - for (int i = 0; i < multiTargetRefProps_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, multiTargetRefProps_.get(i)); - } - for (int i = 0; i < numberArrayProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, numberArrayProperties_.get(i)); - } - for (int i = 0; i < intArrayProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, intArrayProperties_.get(i)); - } - for (int i = 0; i < textArrayProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(6, textArrayProperties_.get(i)); - } - for (int i = 0; i < booleanArrayProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(7, booleanArrayProperties_.get(i)); - } - for (int i = 0; i < objectProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(8, objectProperties_.get(i)); - } - for (int i = 0; i < objectArrayProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(9, objectArrayProperties_.get(i)); - } - { - int dataSize = 0; - for (int i = 0; i < emptyListProps_.size(); i++) { - dataSize += computeStringSizeNoTag(emptyListProps_.getRaw(i)); - } - size += dataSize; - size += 1 * getEmptyListPropsList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties) obj; - - if (hasNonRefProperties() != other.hasNonRefProperties()) return false; - if (hasNonRefProperties()) { - if (!getNonRefProperties() - .equals(other.getNonRefProperties())) return false; - } - if (!getSingleTargetRefPropsList() - .equals(other.getSingleTargetRefPropsList())) return false; - if (!getMultiTargetRefPropsList() - .equals(other.getMultiTargetRefPropsList())) return false; - if (!getNumberArrayPropertiesList() - .equals(other.getNumberArrayPropertiesList())) return false; - if (!getIntArrayPropertiesList() - .equals(other.getIntArrayPropertiesList())) return false; - if (!getTextArrayPropertiesList() - .equals(other.getTextArrayPropertiesList())) return false; - if (!getBooleanArrayPropertiesList() - .equals(other.getBooleanArrayPropertiesList())) return false; - if (!getObjectPropertiesList() - .equals(other.getObjectPropertiesList())) return false; - if (!getObjectArrayPropertiesList() - .equals(other.getObjectArrayPropertiesList())) return false; - if (!getEmptyListPropsList() - .equals(other.getEmptyListPropsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (hasNonRefProperties()) { - hash = (37 * hash) + NON_REF_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getNonRefProperties().hashCode(); - } - if (getSingleTargetRefPropsCount() > 0) { - hash = (37 * hash) + SINGLE_TARGET_REF_PROPS_FIELD_NUMBER; - hash = (53 * hash) + getSingleTargetRefPropsList().hashCode(); - } - if (getMultiTargetRefPropsCount() > 0) { - hash = (37 * hash) + MULTI_TARGET_REF_PROPS_FIELD_NUMBER; - hash = (53 * hash) + getMultiTargetRefPropsList().hashCode(); - } - if (getNumberArrayPropertiesCount() > 0) { - hash = (37 * hash) + NUMBER_ARRAY_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getNumberArrayPropertiesList().hashCode(); - } - if (getIntArrayPropertiesCount() > 0) { - hash = (37 * hash) + INT_ARRAY_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getIntArrayPropertiesList().hashCode(); - } - if (getTextArrayPropertiesCount() > 0) { - hash = (37 * hash) + TEXT_ARRAY_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getTextArrayPropertiesList().hashCode(); - } - if (getBooleanArrayPropertiesCount() > 0) { - hash = (37 * hash) + BOOLEAN_ARRAY_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getBooleanArrayPropertiesList().hashCode(); - } - if (getObjectPropertiesCount() > 0) { - hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getObjectPropertiesList().hashCode(); - } - if (getObjectArrayPropertiesCount() > 0) { - hash = (37 * hash) + OBJECT_ARRAY_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getObjectArrayPropertiesList().hashCode(); - } - if (getEmptyListPropsCount() > 0) { - hash = (37 * hash) + EMPTY_LIST_PROPS_FIELD_NUMBER; - hash = (53 * hash) + getEmptyListPropsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.Properties} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.Properties) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getNonRefPropertiesFieldBuilder(); - getSingleTargetRefPropsFieldBuilder(); - getMultiTargetRefPropsFieldBuilder(); - getNumberArrayPropertiesFieldBuilder(); - getIntArrayPropertiesFieldBuilder(); - getTextArrayPropertiesFieldBuilder(); - getBooleanArrayPropertiesFieldBuilder(); - getObjectPropertiesFieldBuilder(); - getObjectArrayPropertiesFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - nonRefProperties_ = null; - if (nonRefPropertiesBuilder_ != null) { - nonRefPropertiesBuilder_.dispose(); - nonRefPropertiesBuilder_ = null; - } - if (singleTargetRefPropsBuilder_ == null) { - singleTargetRefProps_ = java.util.Collections.emptyList(); - } else { - singleTargetRefProps_ = null; - singleTargetRefPropsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000002); - if (multiTargetRefPropsBuilder_ == null) { - multiTargetRefProps_ = java.util.Collections.emptyList(); - } else { - multiTargetRefProps_ = null; - multiTargetRefPropsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000004); - if (numberArrayPropertiesBuilder_ == null) { - numberArrayProperties_ = java.util.Collections.emptyList(); - } else { - numberArrayProperties_ = null; - numberArrayPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000008); - if (intArrayPropertiesBuilder_ == null) { - intArrayProperties_ = java.util.Collections.emptyList(); - } else { - intArrayProperties_ = null; - intArrayPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000010); - if (textArrayPropertiesBuilder_ == null) { - textArrayProperties_ = java.util.Collections.emptyList(); - } else { - textArrayProperties_ = null; - textArrayPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000020); - if (booleanArrayPropertiesBuilder_ == null) { - booleanArrayProperties_ = java.util.Collections.emptyList(); - } else { - booleanArrayProperties_ = null; - booleanArrayPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000040); - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - } else { - objectProperties_ = null; - objectPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000080); - if (objectArrayPropertiesBuilder_ == null) { - objectArrayProperties_ = java.util.Collections.emptyList(); - } else { - objectArrayProperties_ = null; - objectArrayPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000100); - emptyListProps_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties result) { - if (singleTargetRefPropsBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0)) { - singleTargetRefProps_ = java.util.Collections.unmodifiableList(singleTargetRefProps_); - bitField0_ = (bitField0_ & ~0x00000002); - } - result.singleTargetRefProps_ = singleTargetRefProps_; - } else { - result.singleTargetRefProps_ = singleTargetRefPropsBuilder_.build(); - } - if (multiTargetRefPropsBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0)) { - multiTargetRefProps_ = java.util.Collections.unmodifiableList(multiTargetRefProps_); - bitField0_ = (bitField0_ & ~0x00000004); - } - result.multiTargetRefProps_ = multiTargetRefProps_; - } else { - result.multiTargetRefProps_ = multiTargetRefPropsBuilder_.build(); - } - if (numberArrayPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000008) != 0)) { - numberArrayProperties_ = java.util.Collections.unmodifiableList(numberArrayProperties_); - bitField0_ = (bitField0_ & ~0x00000008); - } - result.numberArrayProperties_ = numberArrayProperties_; - } else { - result.numberArrayProperties_ = numberArrayPropertiesBuilder_.build(); - } - if (intArrayPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000010) != 0)) { - intArrayProperties_ = java.util.Collections.unmodifiableList(intArrayProperties_); - bitField0_ = (bitField0_ & ~0x00000010); - } - result.intArrayProperties_ = intArrayProperties_; - } else { - result.intArrayProperties_ = intArrayPropertiesBuilder_.build(); - } - if (textArrayPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000020) != 0)) { - textArrayProperties_ = java.util.Collections.unmodifiableList(textArrayProperties_); - bitField0_ = (bitField0_ & ~0x00000020); - } - result.textArrayProperties_ = textArrayProperties_; - } else { - result.textArrayProperties_ = textArrayPropertiesBuilder_.build(); - } - if (booleanArrayPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000040) != 0)) { - booleanArrayProperties_ = java.util.Collections.unmodifiableList(booleanArrayProperties_); - bitField0_ = (bitField0_ & ~0x00000040); - } - result.booleanArrayProperties_ = booleanArrayProperties_; - } else { - result.booleanArrayProperties_ = booleanArrayPropertiesBuilder_.build(); - } - if (objectPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000080) != 0)) { - objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); - bitField0_ = (bitField0_ & ~0x00000080); - } - result.objectProperties_ = objectProperties_; - } else { - result.objectProperties_ = objectPropertiesBuilder_.build(); - } - if (objectArrayPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000100) != 0)) { - objectArrayProperties_ = java.util.Collections.unmodifiableList(objectArrayProperties_); - bitField0_ = (bitField0_ & ~0x00000100); - } - result.objectArrayProperties_ = objectArrayProperties_; - } else { - result.objectArrayProperties_ = objectArrayPropertiesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties result) { - int from_bitField0_ = bitField0_; - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.nonRefProperties_ = nonRefPropertiesBuilder_ == null - ? nonRefProperties_ - : nonRefPropertiesBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000200) != 0)) { - emptyListProps_.makeImmutable(); - result.emptyListProps_ = emptyListProps_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance()) return this; - if (other.hasNonRefProperties()) { - mergeNonRefProperties(other.getNonRefProperties()); - } - if (singleTargetRefPropsBuilder_ == null) { - if (!other.singleTargetRefProps_.isEmpty()) { - if (singleTargetRefProps_.isEmpty()) { - singleTargetRefProps_ = other.singleTargetRefProps_; - bitField0_ = (bitField0_ & ~0x00000002); - } else { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.addAll(other.singleTargetRefProps_); - } - onChanged(); - } - } else { - if (!other.singleTargetRefProps_.isEmpty()) { - if (singleTargetRefPropsBuilder_.isEmpty()) { - singleTargetRefPropsBuilder_.dispose(); - singleTargetRefPropsBuilder_ = null; - singleTargetRefProps_ = other.singleTargetRefProps_; - bitField0_ = (bitField0_ & ~0x00000002); - singleTargetRefPropsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getSingleTargetRefPropsFieldBuilder() : null; - } else { - singleTargetRefPropsBuilder_.addAllMessages(other.singleTargetRefProps_); - } - } - } - if (multiTargetRefPropsBuilder_ == null) { - if (!other.multiTargetRefProps_.isEmpty()) { - if (multiTargetRefProps_.isEmpty()) { - multiTargetRefProps_ = other.multiTargetRefProps_; - bitField0_ = (bitField0_ & ~0x00000004); - } else { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.addAll(other.multiTargetRefProps_); - } - onChanged(); - } - } else { - if (!other.multiTargetRefProps_.isEmpty()) { - if (multiTargetRefPropsBuilder_.isEmpty()) { - multiTargetRefPropsBuilder_.dispose(); - multiTargetRefPropsBuilder_ = null; - multiTargetRefProps_ = other.multiTargetRefProps_; - bitField0_ = (bitField0_ & ~0x00000004); - multiTargetRefPropsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getMultiTargetRefPropsFieldBuilder() : null; - } else { - multiTargetRefPropsBuilder_.addAllMessages(other.multiTargetRefProps_); - } - } - } - if (numberArrayPropertiesBuilder_ == null) { - if (!other.numberArrayProperties_.isEmpty()) { - if (numberArrayProperties_.isEmpty()) { - numberArrayProperties_ = other.numberArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000008); - } else { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.addAll(other.numberArrayProperties_); - } - onChanged(); - } - } else { - if (!other.numberArrayProperties_.isEmpty()) { - if (numberArrayPropertiesBuilder_.isEmpty()) { - numberArrayPropertiesBuilder_.dispose(); - numberArrayPropertiesBuilder_ = null; - numberArrayProperties_ = other.numberArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000008); - numberArrayPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getNumberArrayPropertiesFieldBuilder() : null; - } else { - numberArrayPropertiesBuilder_.addAllMessages(other.numberArrayProperties_); - } - } - } - if (intArrayPropertiesBuilder_ == null) { - if (!other.intArrayProperties_.isEmpty()) { - if (intArrayProperties_.isEmpty()) { - intArrayProperties_ = other.intArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000010); - } else { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.addAll(other.intArrayProperties_); - } - onChanged(); - } - } else { - if (!other.intArrayProperties_.isEmpty()) { - if (intArrayPropertiesBuilder_.isEmpty()) { - intArrayPropertiesBuilder_.dispose(); - intArrayPropertiesBuilder_ = null; - intArrayProperties_ = other.intArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000010); - intArrayPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getIntArrayPropertiesFieldBuilder() : null; - } else { - intArrayPropertiesBuilder_.addAllMessages(other.intArrayProperties_); - } - } - } - if (textArrayPropertiesBuilder_ == null) { - if (!other.textArrayProperties_.isEmpty()) { - if (textArrayProperties_.isEmpty()) { - textArrayProperties_ = other.textArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000020); - } else { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.addAll(other.textArrayProperties_); - } - onChanged(); - } - } else { - if (!other.textArrayProperties_.isEmpty()) { - if (textArrayPropertiesBuilder_.isEmpty()) { - textArrayPropertiesBuilder_.dispose(); - textArrayPropertiesBuilder_ = null; - textArrayProperties_ = other.textArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000020); - textArrayPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getTextArrayPropertiesFieldBuilder() : null; - } else { - textArrayPropertiesBuilder_.addAllMessages(other.textArrayProperties_); - } - } - } - if (booleanArrayPropertiesBuilder_ == null) { - if (!other.booleanArrayProperties_.isEmpty()) { - if (booleanArrayProperties_.isEmpty()) { - booleanArrayProperties_ = other.booleanArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000040); - } else { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.addAll(other.booleanArrayProperties_); - } - onChanged(); - } - } else { - if (!other.booleanArrayProperties_.isEmpty()) { - if (booleanArrayPropertiesBuilder_.isEmpty()) { - booleanArrayPropertiesBuilder_.dispose(); - booleanArrayPropertiesBuilder_ = null; - booleanArrayProperties_ = other.booleanArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000040); - booleanArrayPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getBooleanArrayPropertiesFieldBuilder() : null; - } else { - booleanArrayPropertiesBuilder_.addAllMessages(other.booleanArrayProperties_); - } - } - } - if (objectPropertiesBuilder_ == null) { - if (!other.objectProperties_.isEmpty()) { - if (objectProperties_.isEmpty()) { - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000080); - } else { - ensureObjectPropertiesIsMutable(); - objectProperties_.addAll(other.objectProperties_); - } - onChanged(); - } - } else { - if (!other.objectProperties_.isEmpty()) { - if (objectPropertiesBuilder_.isEmpty()) { - objectPropertiesBuilder_.dispose(); - objectPropertiesBuilder_ = null; - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000080); - objectPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectPropertiesFieldBuilder() : null; - } else { - objectPropertiesBuilder_.addAllMessages(other.objectProperties_); - } - } - } - if (objectArrayPropertiesBuilder_ == null) { - if (!other.objectArrayProperties_.isEmpty()) { - if (objectArrayProperties_.isEmpty()) { - objectArrayProperties_ = other.objectArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000100); - } else { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.addAll(other.objectArrayProperties_); - } - onChanged(); - } - } else { - if (!other.objectArrayProperties_.isEmpty()) { - if (objectArrayPropertiesBuilder_.isEmpty()) { - objectArrayPropertiesBuilder_.dispose(); - objectArrayPropertiesBuilder_ = null; - objectArrayProperties_ = other.objectArrayProperties_; - bitField0_ = (bitField0_ & ~0x00000100); - objectArrayPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectArrayPropertiesFieldBuilder() : null; - } else { - objectArrayPropertiesBuilder_.addAllMessages(other.objectArrayProperties_); - } - } - } - if (!other.emptyListProps_.isEmpty()) { - if (emptyListProps_.isEmpty()) { - emptyListProps_ = other.emptyListProps_; - bitField0_ |= 0x00000200; - } else { - ensureEmptyListPropsIsMutable(); - emptyListProps_.addAll(other.emptyListProps_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - input.readMessage( - getNonRefPropertiesFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.parser(), - extensionRegistry); - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.add(m); - } else { - singleTargetRefPropsBuilder_.addMessage(m); - } - break; - } // case 18 - case 26: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.parser(), - extensionRegistry); - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.add(m); - } else { - multiTargetRefPropsBuilder_.addMessage(m); - } - break; - } // case 26 - case 34: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.parser(), - extensionRegistry); - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.add(m); - } else { - numberArrayPropertiesBuilder_.addMessage(m); - } - break; - } // case 34 - case 42: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.parser(), - extensionRegistry); - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.add(m); - } else { - intArrayPropertiesBuilder_.addMessage(m); - } - break; - } // case 42 - case 50: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.parser(), - extensionRegistry); - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.add(m); - } else { - textArrayPropertiesBuilder_.addMessage(m); - } - break; - } // case 50 - case 58: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.parser(), - extensionRegistry); - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.add(m); - } else { - booleanArrayPropertiesBuilder_.addMessage(m); - } - break; - } // case 58 - case 66: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.parser(), - extensionRegistry); - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(m); - } else { - objectPropertiesBuilder_.addMessage(m); - } - break; - } // case 66 - case 74: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.parser(), - extensionRegistry); - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.add(m); - } else { - objectArrayPropertiesBuilder_.addMessage(m); - } - break; - } // case 74 - case 82: { - java.lang.String s = input.readStringRequireUtf8(); - ensureEmptyListPropsIsMutable(); - emptyListProps_.add(s); - break; - } // case 82 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.Struct nonRefProperties_; - private com.google.protobuf.SingleFieldBuilderV3< - com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder> nonRefPropertiesBuilder_; - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return Whether the nonRefProperties field is set. - */ - public boolean hasNonRefProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - * @return The nonRefProperties. - */ - public com.google.protobuf.Struct getNonRefProperties() { - if (nonRefPropertiesBuilder_ == null) { - return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; - } else { - return nonRefPropertiesBuilder_.getMessage(); - } - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public Builder setNonRefProperties(com.google.protobuf.Struct value) { - if (nonRefPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nonRefProperties_ = value; - } else { - nonRefPropertiesBuilder_.setMessage(value); - } - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public Builder setNonRefProperties( - com.google.protobuf.Struct.Builder builderForValue) { - if (nonRefPropertiesBuilder_ == null) { - nonRefProperties_ = builderForValue.build(); - } else { - nonRefPropertiesBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public Builder mergeNonRefProperties(com.google.protobuf.Struct value) { - if (nonRefPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0) && - nonRefProperties_ != null && - nonRefProperties_ != com.google.protobuf.Struct.getDefaultInstance()) { - getNonRefPropertiesBuilder().mergeFrom(value); - } else { - nonRefProperties_ = value; - } - } else { - nonRefPropertiesBuilder_.mergeFrom(value); - } - if (nonRefProperties_ != null) { - bitField0_ |= 0x00000001; - onChanged(); - } - return this; - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public Builder clearNonRefProperties() { - bitField0_ = (bitField0_ & ~0x00000001); - nonRefProperties_ = null; - if (nonRefPropertiesBuilder_ != null) { - nonRefPropertiesBuilder_.dispose(); - nonRefPropertiesBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public com.google.protobuf.Struct.Builder getNonRefPropertiesBuilder() { - bitField0_ |= 0x00000001; - onChanged(); - return getNonRefPropertiesFieldBuilder().getBuilder(); - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() { - if (nonRefPropertiesBuilder_ != null) { - return nonRefPropertiesBuilder_.getMessageOrBuilder(); - } else { - return nonRefProperties_ == null ? - com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; - } - } - /** - * .google.protobuf.Struct non_ref_properties = 1; - */ - private com.google.protobuf.SingleFieldBuilderV3< - com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder> - getNonRefPropertiesFieldBuilder() { - if (nonRefPropertiesBuilder_ == null) { - nonRefPropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder>( - getNonRefProperties(), - getParentForChildren(), - isClean()); - nonRefProperties_ = null; - } - return nonRefPropertiesBuilder_; - } - - private java.util.List singleTargetRefProps_ = - java.util.Collections.emptyList(); - private void ensureSingleTargetRefPropsIsMutable() { - if (!((bitField0_ & 0x00000002) != 0)) { - singleTargetRefProps_ = new java.util.ArrayList(singleTargetRefProps_); - bitField0_ |= 0x00000002; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder> singleTargetRefPropsBuilder_; - - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public java.util.List getSingleTargetRefPropsList() { - if (singleTargetRefPropsBuilder_ == null) { - return java.util.Collections.unmodifiableList(singleTargetRefProps_); - } else { - return singleTargetRefPropsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public int getSingleTargetRefPropsCount() { - if (singleTargetRefPropsBuilder_ == null) { - return singleTargetRefProps_.size(); - } else { - return singleTargetRefPropsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index) { - if (singleTargetRefPropsBuilder_ == null) { - return singleTargetRefProps_.get(index); - } else { - return singleTargetRefPropsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder setSingleTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { - if (singleTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.set(index, value); - onChanged(); - } else { - singleTargetRefPropsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder setSingleTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.set(index, builderForValue.build()); - onChanged(); - } else { - singleTargetRefPropsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder addSingleTargetRefProps(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { - if (singleTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.add(value); - onChanged(); - } else { - singleTargetRefPropsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder addSingleTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { - if (singleTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.add(index, value); - onChanged(); - } else { - singleTargetRefPropsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder addSingleTargetRefProps( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.add(builderForValue.build()); - onChanged(); - } else { - singleTargetRefPropsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder addSingleTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.add(index, builderForValue.build()); - onChanged(); - } else { - singleTargetRefPropsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder addAllSingleTargetRefProps( - java.lang.Iterable values) { - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, singleTargetRefProps_); - onChanged(); - } else { - singleTargetRefPropsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder clearSingleTargetRefProps() { - if (singleTargetRefPropsBuilder_ == null) { - singleTargetRefProps_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - } else { - singleTargetRefPropsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public Builder removeSingleTargetRefProps(int index) { - if (singleTargetRefPropsBuilder_ == null) { - ensureSingleTargetRefPropsIsMutable(); - singleTargetRefProps_.remove(index); - onChanged(); - } else { - singleTargetRefPropsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder getSingleTargetRefPropsBuilder( - int index) { - return getSingleTargetRefPropsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( - int index) { - if (singleTargetRefPropsBuilder_ == null) { - return singleTargetRefProps_.get(index); } else { - return singleTargetRefPropsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public java.util.List - getSingleTargetRefPropsOrBuilderList() { - if (singleTargetRefPropsBuilder_ != null) { - return singleTargetRefPropsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(singleTargetRefProps_); - } - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder addSingleTargetRefPropsBuilder() { - return getSingleTargetRefPropsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder addSingleTargetRefPropsBuilder( - int index) { - return getSingleTargetRefPropsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; - */ - public java.util.List - getSingleTargetRefPropsBuilderList() { - return getSingleTargetRefPropsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder> - getSingleTargetRefPropsFieldBuilder() { - if (singleTargetRefPropsBuilder_ == null) { - singleTargetRefPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder>( - singleTargetRefProps_, - ((bitField0_ & 0x00000002) != 0), - getParentForChildren(), - isClean()); - singleTargetRefProps_ = null; - } - return singleTargetRefPropsBuilder_; - } - - private java.util.List multiTargetRefProps_ = - java.util.Collections.emptyList(); - private void ensureMultiTargetRefPropsIsMutable() { - if (!((bitField0_ & 0x00000004) != 0)) { - multiTargetRefProps_ = new java.util.ArrayList(multiTargetRefProps_); - bitField0_ |= 0x00000004; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder> multiTargetRefPropsBuilder_; - - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public java.util.List getMultiTargetRefPropsList() { - if (multiTargetRefPropsBuilder_ == null) { - return java.util.Collections.unmodifiableList(multiTargetRefProps_); - } else { - return multiTargetRefPropsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public int getMultiTargetRefPropsCount() { - if (multiTargetRefPropsBuilder_ == null) { - return multiTargetRefProps_.size(); - } else { - return multiTargetRefPropsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index) { - if (multiTargetRefPropsBuilder_ == null) { - return multiTargetRefProps_.get(index); - } else { - return multiTargetRefPropsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder setMultiTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { - if (multiTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.set(index, value); - onChanged(); - } else { - multiTargetRefPropsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder setMultiTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.set(index, builderForValue.build()); - onChanged(); - } else { - multiTargetRefPropsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder addMultiTargetRefProps(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { - if (multiTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.add(value); - onChanged(); - } else { - multiTargetRefPropsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder addMultiTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { - if (multiTargetRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.add(index, value); - onChanged(); - } else { - multiTargetRefPropsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder addMultiTargetRefProps( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.add(builderForValue.build()); - onChanged(); - } else { - multiTargetRefPropsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder addMultiTargetRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.add(index, builderForValue.build()); - onChanged(); - } else { - multiTargetRefPropsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder addAllMultiTargetRefProps( - java.lang.Iterable values) { - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, multiTargetRefProps_); - onChanged(); - } else { - multiTargetRefPropsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder clearMultiTargetRefProps() { - if (multiTargetRefPropsBuilder_ == null) { - multiTargetRefProps_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - } else { - multiTargetRefPropsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public Builder removeMultiTargetRefProps(int index) { - if (multiTargetRefPropsBuilder_ == null) { - ensureMultiTargetRefPropsIsMutable(); - multiTargetRefProps_.remove(index); - onChanged(); - } else { - multiTargetRefPropsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder getMultiTargetRefPropsBuilder( - int index) { - return getMultiTargetRefPropsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( - int index) { - if (multiTargetRefPropsBuilder_ == null) { - return multiTargetRefProps_.get(index); } else { - return multiTargetRefPropsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public java.util.List - getMultiTargetRefPropsOrBuilderList() { - if (multiTargetRefPropsBuilder_ != null) { - return multiTargetRefPropsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(multiTargetRefProps_); - } - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder addMultiTargetRefPropsBuilder() { - return getMultiTargetRefPropsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder addMultiTargetRefPropsBuilder( - int index) { - return getMultiTargetRefPropsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; - */ - public java.util.List - getMultiTargetRefPropsBuilderList() { - return getMultiTargetRefPropsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder> - getMultiTargetRefPropsFieldBuilder() { - if (multiTargetRefPropsBuilder_ == null) { - multiTargetRefPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder>( - multiTargetRefProps_, - ((bitField0_ & 0x00000004) != 0), - getParentForChildren(), - isClean()); - multiTargetRefProps_ = null; - } - return multiTargetRefPropsBuilder_; - } - - private java.util.List numberArrayProperties_ = - java.util.Collections.emptyList(); - private void ensureNumberArrayPropertiesIsMutable() { - if (!((bitField0_ & 0x00000008) != 0)) { - numberArrayProperties_ = new java.util.ArrayList(numberArrayProperties_); - bitField0_ |= 0x00000008; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> numberArrayPropertiesBuilder_; - - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public java.util.List getNumberArrayPropertiesList() { - if (numberArrayPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(numberArrayProperties_); - } else { - return numberArrayPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public int getNumberArrayPropertiesCount() { - if (numberArrayPropertiesBuilder_ == null) { - return numberArrayProperties_.size(); - } else { - return numberArrayPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) { - if (numberArrayPropertiesBuilder_ == null) { - return numberArrayProperties_.get(index); - } else { - return numberArrayPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder setNumberArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) { - if (numberArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.set(index, value); - onChanged(); - } else { - numberArrayPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder setNumberArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - numberArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder addNumberArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) { - if (numberArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.add(value); - onChanged(); - } else { - numberArrayPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder addNumberArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) { - if (numberArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.add(index, value); - onChanged(); - } else { - numberArrayPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder addNumberArrayProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.add(builderForValue.build()); - onChanged(); - } else { - numberArrayPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder addNumberArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - numberArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder addAllNumberArrayProperties( - java.lang.Iterable values) { - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, numberArrayProperties_); - onChanged(); - } else { - numberArrayPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder clearNumberArrayProperties() { - if (numberArrayPropertiesBuilder_ == null) { - numberArrayProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - } else { - numberArrayPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public Builder removeNumberArrayProperties(int index) { - if (numberArrayPropertiesBuilder_ == null) { - ensureNumberArrayPropertiesIsMutable(); - numberArrayProperties_.remove(index); - onChanged(); - } else { - numberArrayPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder getNumberArrayPropertiesBuilder( - int index) { - return getNumberArrayPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( - int index) { - if (numberArrayPropertiesBuilder_ == null) { - return numberArrayProperties_.get(index); } else { - return numberArrayPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public java.util.List - getNumberArrayPropertiesOrBuilderList() { - if (numberArrayPropertiesBuilder_ != null) { - return numberArrayPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(numberArrayProperties_); - } - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder() { - return getNumberArrayPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder( - int index) { - return getNumberArrayPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; - */ - public java.util.List - getNumberArrayPropertiesBuilderList() { - return getNumberArrayPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> - getNumberArrayPropertiesFieldBuilder() { - if (numberArrayPropertiesBuilder_ == null) { - numberArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder>( - numberArrayProperties_, - ((bitField0_ & 0x00000008) != 0), - getParentForChildren(), - isClean()); - numberArrayProperties_ = null; - } - return numberArrayPropertiesBuilder_; - } - - private java.util.List intArrayProperties_ = - java.util.Collections.emptyList(); - private void ensureIntArrayPropertiesIsMutable() { - if (!((bitField0_ & 0x00000010) != 0)) { - intArrayProperties_ = new java.util.ArrayList(intArrayProperties_); - bitField0_ |= 0x00000010; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder> intArrayPropertiesBuilder_; - - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public java.util.List getIntArrayPropertiesList() { - if (intArrayPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(intArrayProperties_); - } else { - return intArrayPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public int getIntArrayPropertiesCount() { - if (intArrayPropertiesBuilder_ == null) { - return intArrayProperties_.size(); - } else { - return intArrayPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) { - if (intArrayPropertiesBuilder_ == null) { - return intArrayProperties_.get(index); - } else { - return intArrayPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder setIntArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) { - if (intArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.set(index, value); - onChanged(); - } else { - intArrayPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder setIntArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - intArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder addIntArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) { - if (intArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.add(value); - onChanged(); - } else { - intArrayPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder addIntArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) { - if (intArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.add(index, value); - onChanged(); - } else { - intArrayPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder addIntArrayProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.add(builderForValue.build()); - onChanged(); - } else { - intArrayPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder addIntArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - intArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder addAllIntArrayProperties( - java.lang.Iterable values) { - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, intArrayProperties_); - onChanged(); - } else { - intArrayPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder clearIntArrayProperties() { - if (intArrayPropertiesBuilder_ == null) { - intArrayProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000010); - onChanged(); - } else { - intArrayPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public Builder removeIntArrayProperties(int index) { - if (intArrayPropertiesBuilder_ == null) { - ensureIntArrayPropertiesIsMutable(); - intArrayProperties_.remove(index); - onChanged(); - } else { - intArrayPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder getIntArrayPropertiesBuilder( - int index) { - return getIntArrayPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( - int index) { - if (intArrayPropertiesBuilder_ == null) { - return intArrayProperties_.get(index); } else { - return intArrayPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public java.util.List - getIntArrayPropertiesOrBuilderList() { - if (intArrayPropertiesBuilder_ != null) { - return intArrayPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(intArrayProperties_); - } - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder() { - return getIntArrayPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder( - int index) { - return getIntArrayPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; - */ - public java.util.List - getIntArrayPropertiesBuilderList() { - return getIntArrayPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder> - getIntArrayPropertiesFieldBuilder() { - if (intArrayPropertiesBuilder_ == null) { - intArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder>( - intArrayProperties_, - ((bitField0_ & 0x00000010) != 0), - getParentForChildren(), - isClean()); - intArrayProperties_ = null; - } - return intArrayPropertiesBuilder_; - } - - private java.util.List textArrayProperties_ = - java.util.Collections.emptyList(); - private void ensureTextArrayPropertiesIsMutable() { - if (!((bitField0_ & 0x00000020) != 0)) { - textArrayProperties_ = new java.util.ArrayList(textArrayProperties_); - bitField0_ |= 0x00000020; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder> textArrayPropertiesBuilder_; - - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public java.util.List getTextArrayPropertiesList() { - if (textArrayPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(textArrayProperties_); - } else { - return textArrayPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public int getTextArrayPropertiesCount() { - if (textArrayPropertiesBuilder_ == null) { - return textArrayProperties_.size(); - } else { - return textArrayPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) { - if (textArrayPropertiesBuilder_ == null) { - return textArrayProperties_.get(index); - } else { - return textArrayPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder setTextArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) { - if (textArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.set(index, value); - onChanged(); - } else { - textArrayPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder setTextArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - textArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder addTextArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) { - if (textArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.add(value); - onChanged(); - } else { - textArrayPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder addTextArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) { - if (textArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.add(index, value); - onChanged(); - } else { - textArrayPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder addTextArrayProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.add(builderForValue.build()); - onChanged(); - } else { - textArrayPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder addTextArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - textArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder addAllTextArrayProperties( - java.lang.Iterable values) { - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, textArrayProperties_); - onChanged(); - } else { - textArrayPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder clearTextArrayProperties() { - if (textArrayPropertiesBuilder_ == null) { - textArrayProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000020); - onChanged(); - } else { - textArrayPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public Builder removeTextArrayProperties(int index) { - if (textArrayPropertiesBuilder_ == null) { - ensureTextArrayPropertiesIsMutable(); - textArrayProperties_.remove(index); - onChanged(); - } else { - textArrayPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder getTextArrayPropertiesBuilder( - int index) { - return getTextArrayPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( - int index) { - if (textArrayPropertiesBuilder_ == null) { - return textArrayProperties_.get(index); } else { - return textArrayPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public java.util.List - getTextArrayPropertiesOrBuilderList() { - if (textArrayPropertiesBuilder_ != null) { - return textArrayPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(textArrayProperties_); - } - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder() { - return getTextArrayPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder( - int index) { - return getTextArrayPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; - */ - public java.util.List - getTextArrayPropertiesBuilderList() { - return getTextArrayPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder> - getTextArrayPropertiesFieldBuilder() { - if (textArrayPropertiesBuilder_ == null) { - textArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder>( - textArrayProperties_, - ((bitField0_ & 0x00000020) != 0), - getParentForChildren(), - isClean()); - textArrayProperties_ = null; - } - return textArrayPropertiesBuilder_; - } - - private java.util.List booleanArrayProperties_ = - java.util.Collections.emptyList(); - private void ensureBooleanArrayPropertiesIsMutable() { - if (!((bitField0_ & 0x00000040) != 0)) { - booleanArrayProperties_ = new java.util.ArrayList(booleanArrayProperties_); - bitField0_ |= 0x00000040; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> booleanArrayPropertiesBuilder_; - - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public java.util.List getBooleanArrayPropertiesList() { - if (booleanArrayPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(booleanArrayProperties_); - } else { - return booleanArrayPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public int getBooleanArrayPropertiesCount() { - if (booleanArrayPropertiesBuilder_ == null) { - return booleanArrayProperties_.size(); - } else { - return booleanArrayPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) { - if (booleanArrayPropertiesBuilder_ == null) { - return booleanArrayProperties_.get(index); - } else { - return booleanArrayPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder setBooleanArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) { - if (booleanArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.set(index, value); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder setBooleanArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder addBooleanArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) { - if (booleanArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.add(value); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder addBooleanArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) { - if (booleanArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.add(index, value); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder addBooleanArrayProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.add(builderForValue.build()); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder addBooleanArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder addAllBooleanArrayProperties( - java.lang.Iterable values) { - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, booleanArrayProperties_); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder clearBooleanArrayProperties() { - if (booleanArrayPropertiesBuilder_ == null) { - booleanArrayProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000040); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public Builder removeBooleanArrayProperties(int index) { - if (booleanArrayPropertiesBuilder_ == null) { - ensureBooleanArrayPropertiesIsMutable(); - booleanArrayProperties_.remove(index); - onChanged(); - } else { - booleanArrayPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder getBooleanArrayPropertiesBuilder( - int index) { - return getBooleanArrayPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( - int index) { - if (booleanArrayPropertiesBuilder_ == null) { - return booleanArrayProperties_.get(index); } else { - return booleanArrayPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public java.util.List - getBooleanArrayPropertiesOrBuilderList() { - if (booleanArrayPropertiesBuilder_ != null) { - return booleanArrayPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(booleanArrayProperties_); - } - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder() { - return getBooleanArrayPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder( - int index) { - return getBooleanArrayPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; - */ - public java.util.List - getBooleanArrayPropertiesBuilderList() { - return getBooleanArrayPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> - getBooleanArrayPropertiesFieldBuilder() { - if (booleanArrayPropertiesBuilder_ == null) { - booleanArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder>( - booleanArrayProperties_, - ((bitField0_ & 0x00000040) != 0), - getParentForChildren(), - isClean()); - booleanArrayProperties_ = null; - } - return booleanArrayPropertiesBuilder_; - } - - private java.util.List objectProperties_ = - java.util.Collections.emptyList(); - private void ensureObjectPropertiesIsMutable() { - if (!((bitField0_ & 0x00000080) != 0)) { - objectProperties_ = new java.util.ArrayList(objectProperties_); - bitField0_ |= 0x00000080; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder> objectPropertiesBuilder_; - - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public java.util.List getObjectPropertiesList() { - if (objectPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(objectProperties_); - } else { - return objectPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public int getObjectPropertiesCount() { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.size(); - } else { - return objectPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); - } else { - return objectPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder addObjectProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder addObjectProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder addAllObjectProperties( - java.lang.Iterable values) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objectProperties_); - onChanged(); - } else { - objectPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder clearObjectProperties() { - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000080); - onChanged(); - } else { - objectPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public Builder removeObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.remove(index); - onChanged(); - } else { - objectPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder getObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( - int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); } else { - return objectPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public java.util.List - getObjectPropertiesOrBuilderList() { - if (objectPropertiesBuilder_ != null) { - return objectPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objectProperties_); - } - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder() { - return getObjectPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectProperties object_properties = 8; - */ - public java.util.List - getObjectPropertiesBuilderList() { - return getObjectPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder> - getObjectPropertiesFieldBuilder() { - if (objectPropertiesBuilder_ == null) { - objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder>( - objectProperties_, - ((bitField0_ & 0x00000080) != 0), - getParentForChildren(), - isClean()); - objectProperties_ = null; - } - return objectPropertiesBuilder_; - } - - private java.util.List objectArrayProperties_ = - java.util.Collections.emptyList(); - private void ensureObjectArrayPropertiesIsMutable() { - if (!((bitField0_ & 0x00000100) != 0)) { - objectArrayProperties_ = new java.util.ArrayList(objectArrayProperties_); - bitField0_ |= 0x00000100; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> objectArrayPropertiesBuilder_; - - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public java.util.List getObjectArrayPropertiesList() { - if (objectArrayPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(objectArrayProperties_); - } else { - return objectArrayPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public int getObjectArrayPropertiesCount() { - if (objectArrayPropertiesBuilder_ == null) { - return objectArrayProperties_.size(); - } else { - return objectArrayPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) { - if (objectArrayPropertiesBuilder_ == null) { - return objectArrayProperties_.get(index); - } else { - return objectArrayPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder setObjectArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) { - if (objectArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.set(index, value); - onChanged(); - } else { - objectArrayPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder setObjectArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - objectArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder addObjectArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) { - if (objectArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.add(value); - onChanged(); - } else { - objectArrayPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder addObjectArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) { - if (objectArrayPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.add(index, value); - onChanged(); - } else { - objectArrayPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder addObjectArrayProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.add(builderForValue.build()); - onChanged(); - } else { - objectArrayPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder addObjectArrayProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - objectArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder addAllObjectArrayProperties( - java.lang.Iterable values) { - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objectArrayProperties_); - onChanged(); - } else { - objectArrayPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder clearObjectArrayProperties() { - if (objectArrayPropertiesBuilder_ == null) { - objectArrayProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000100); - onChanged(); - } else { - objectArrayPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public Builder removeObjectArrayProperties(int index) { - if (objectArrayPropertiesBuilder_ == null) { - ensureObjectArrayPropertiesIsMutable(); - objectArrayProperties_.remove(index); - onChanged(); - } else { - objectArrayPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder getObjectArrayPropertiesBuilder( - int index) { - return getObjectArrayPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( - int index) { - if (objectArrayPropertiesBuilder_ == null) { - return objectArrayProperties_.get(index); } else { - return objectArrayPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public java.util.List - getObjectArrayPropertiesOrBuilderList() { - if (objectArrayPropertiesBuilder_ != null) { - return objectArrayPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objectArrayProperties_); - } - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder() { - return getObjectArrayPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder( - int index) { - return getObjectArrayPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; - */ - public java.util.List - getObjectArrayPropertiesBuilderList() { - return getObjectArrayPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> - getObjectArrayPropertiesFieldBuilder() { - if (objectArrayPropertiesBuilder_ == null) { - objectArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder>( - objectArrayProperties_, - ((bitField0_ & 0x00000100) != 0), - getParentForChildren(), - isClean()); - objectArrayProperties_ = null; - } - return objectArrayPropertiesBuilder_; - } - - private com.google.protobuf.LazyStringArrayList emptyListProps_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureEmptyListPropsIsMutable() { - if (!emptyListProps_.isModifiable()) { - emptyListProps_ = new com.google.protobuf.LazyStringArrayList(emptyListProps_); - } - bitField0_ |= 0x00000200; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @return A list containing the emptyListProps. - */ - public com.google.protobuf.ProtocolStringList - getEmptyListPropsList() { - emptyListProps_.makeImmutable(); - return emptyListProps_; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @return The count of emptyListProps. - */ - public int getEmptyListPropsCount() { - return emptyListProps_.size(); - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the element to return. - * @return The emptyListProps at the given index. - */ - public java.lang.String getEmptyListProps(int index) { - return emptyListProps_.get(index); - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param index The index of the value to return. - * @return The bytes of the emptyListProps at the given index. - */ - public com.google.protobuf.ByteString - getEmptyListPropsBytes(int index) { - return emptyListProps_.getByteString(index); - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param index The index to set the value at. - * @param value The emptyListProps to set. - * @return This builder for chaining. - */ - public Builder setEmptyListProps( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureEmptyListPropsIsMutable(); - emptyListProps_.set(index, value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param value The emptyListProps to add. - * @return This builder for chaining. - */ - public Builder addEmptyListProps( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureEmptyListPropsIsMutable(); - emptyListProps_.add(value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param values The emptyListProps to add. - * @return This builder for chaining. - */ - public Builder addAllEmptyListProps( - java.lang.Iterable values) { - ensureEmptyListPropsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, emptyListProps_); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @return This builder for chaining. - */ - public Builder clearEmptyListProps() { - emptyListProps_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000200);; - onChanged(); - return this; - } - /** - *
-         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
-         * Weaviate can get the datatype from its schema
-         * 
- * - * repeated string empty_list_props = 10; - * @param value The bytes of the emptyListProps to add. - * @return This builder for chaining. - */ - public Builder addEmptyListPropsBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureEmptyListPropsIsMutable(); - emptyListProps_.add(value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.Properties) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.Properties) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Properties parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface SingleTargetRefPropsOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.SingleTargetRefProps) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - java.util.List - getUuidsList(); - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - int getUuidsCount(); - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - java.lang.String getUuids(int index); - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - com.google.protobuf.ByteString - getUuidsBytes(int index); - - /** - * string prop_name = 2; - * @return The propName. - */ - java.lang.String getPropName(); - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - com.google.protobuf.ByteString - getPropNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.SingleTargetRefProps} - */ - public static final class SingleTargetRefProps extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.SingleTargetRefProps) - SingleTargetRefPropsOrBuilder { - private static final long serialVersionUID = 0L; - // Use SingleTargetRefProps.newBuilder() to construct. - private SingleTargetRefProps(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SingleTargetRefProps() { - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - propName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SingleTargetRefProps(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder.class); - } - - public static final int UUIDS_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - public com.google.protobuf.ProtocolStringList - getUuidsList() { - return uuids_; - } - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - public int getUuidsCount() { - return uuids_.size(); - } - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - public java.lang.String getUuids(int index) { - return uuids_.get(index); - } - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - public com.google.protobuf.ByteString - getUuidsBytes(int index) { - return uuids_.getByteString(index); - } - - public static final int PROP_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - @java.lang.Override - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < uuids_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuids_.getRaw(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < uuids_.size(); i++) { - dataSize += computeStringSizeNoTag(uuids_.getRaw(i)); - } - size += dataSize; - size += 1 * getUuidsList().size(); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps) obj; - - if (!getUuidsList() - .equals(other.getUuidsList())) return false; - if (!getPropName() - .equals(other.getPropName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getUuidsCount() > 0) { - hash = (37 * hash) + UUIDS_FIELD_NUMBER; - hash = (53 * hash) + getUuidsList().hashCode(); - } - hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; - hash = (53 * hash) + getPropName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.SingleTargetRefProps} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.SingleTargetRefProps) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - propName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - uuids_.makeImmutable(); - result.uuids_ = uuids_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.propName_ = propName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()) return this; - if (!other.uuids_.isEmpty()) { - if (uuids_.isEmpty()) { - uuids_ = other.uuids_; - bitField0_ |= 0x00000001; - } else { - ensureUuidsIsMutable(); - uuids_.addAll(other.uuids_); - } - onChanged(); - } - if (!other.getPropName().isEmpty()) { - propName_ = other.propName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureUuidsIsMutable(); - uuids_.add(s); - break; - } // case 10 - case 18: { - propName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureUuidsIsMutable() { - if (!uuids_.isModifiable()) { - uuids_ = new com.google.protobuf.LazyStringArrayList(uuids_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - public com.google.protobuf.ProtocolStringList - getUuidsList() { - uuids_.makeImmutable(); - return uuids_; - } - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - public int getUuidsCount() { - return uuids_.size(); - } - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - public java.lang.String getUuids(int index) { - return uuids_.get(index); - } - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - public com.google.protobuf.ByteString - getUuidsBytes(int index) { - return uuids_.getByteString(index); - } - /** - * repeated string uuids = 1; - * @param index The index to set the value at. - * @param value The uuids to set. - * @return This builder for chaining. - */ - public Builder setUuids( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureUuidsIsMutable(); - uuids_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param value The uuids to add. - * @return This builder for chaining. - */ - public Builder addUuids( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureUuidsIsMutable(); - uuids_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param values The uuids to add. - * @return This builder for chaining. - */ - public Builder addAllUuids( - java.lang.Iterable values) { - ensureUuidsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, uuids_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @return This builder for chaining. - */ - public Builder clearUuids() { - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param value The bytes of the uuids to add. - * @return This builder for chaining. - */ - public Builder addUuidsBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureUuidsIsMutable(); - uuids_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string prop_name = 2; - * @param value The propName to set. - * @return This builder for chaining. - */ - public Builder setPropName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @return This builder for chaining. - */ - public Builder clearPropName() { - propName_ = getDefaultInstance().getPropName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @param value The bytes for propName to set. - * @return This builder for chaining. - */ - public Builder setPropNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.SingleTargetRefProps) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.SingleTargetRefProps) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SingleTargetRefProps parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface MultiTargetRefPropsOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.MultiTargetRefProps) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - java.util.List - getUuidsList(); - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - int getUuidsCount(); - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - java.lang.String getUuids(int index); - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - com.google.protobuf.ByteString - getUuidsBytes(int index); - - /** - * string prop_name = 2; - * @return The propName. - */ - java.lang.String getPropName(); - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - com.google.protobuf.ByteString - getPropNameBytes(); - - /** - * string target_collection = 3; - * @return The targetCollection. - */ - java.lang.String getTargetCollection(); - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - com.google.protobuf.ByteString - getTargetCollectionBytes(); - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.MultiTargetRefProps} - */ - public static final class MultiTargetRefProps extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.MultiTargetRefProps) - MultiTargetRefPropsOrBuilder { - private static final long serialVersionUID = 0L; - // Use MultiTargetRefProps.newBuilder() to construct. - private MultiTargetRefProps(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private MultiTargetRefProps() { - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - propName_ = ""; - targetCollection_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new MultiTargetRefProps(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder.class); - } - - public static final int UUIDS_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - public com.google.protobuf.ProtocolStringList - getUuidsList() { - return uuids_; - } - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - public int getUuidsCount() { - return uuids_.size(); - } - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - public java.lang.String getUuids(int index) { - return uuids_.get(index); - } - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - public com.google.protobuf.ByteString - getUuidsBytes(int index) { - return uuids_.getByteString(index); - } - - public static final int PROP_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - @java.lang.Override - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TARGET_COLLECTION_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 3; - * @return The targetCollection. - */ - @java.lang.Override - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } - } - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < uuids_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuids_.getRaw(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, targetCollection_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < uuids_.size(); i++) { - dataSize += computeStringSizeNoTag(uuids_.getRaw(i)); - } - size += dataSize; - size += 1 * getUuidsList().size(); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, targetCollection_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps) obj; - - if (!getUuidsList() - .equals(other.getUuidsList())) return false; - if (!getPropName() - .equals(other.getPropName())) return false; - if (!getTargetCollection() - .equals(other.getTargetCollection())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getUuidsCount() > 0) { - hash = (37 * hash) + UUIDS_FIELD_NUMBER; - hash = (53 * hash) + getUuidsList().hashCode(); - } - hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; - hash = (53 * hash) + getPropName().hashCode(); - hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getTargetCollection().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObject.MultiTargetRefProps} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.MultiTargetRefProps) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - propName_ = ""; - targetCollection_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - uuids_.makeImmutable(); - result.uuids_ = uuids_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.propName_ = propName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.targetCollection_ = targetCollection_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()) return this; - if (!other.uuids_.isEmpty()) { - if (uuids_.isEmpty()) { - uuids_ = other.uuids_; - bitField0_ |= 0x00000001; - } else { - ensureUuidsIsMutable(); - uuids_.addAll(other.uuids_); - } - onChanged(); - } - if (!other.getPropName().isEmpty()) { - propName_ = other.propName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getTargetCollection().isEmpty()) { - targetCollection_ = other.targetCollection_; - bitField0_ |= 0x00000004; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureUuidsIsMutable(); - uuids_.add(s); - break; - } // case 10 - case 18: { - propName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - targetCollection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureUuidsIsMutable() { - if (!uuids_.isModifiable()) { - uuids_ = new com.google.protobuf.LazyStringArrayList(uuids_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string uuids = 1; - * @return A list containing the uuids. - */ - public com.google.protobuf.ProtocolStringList - getUuidsList() { - uuids_.makeImmutable(); - return uuids_; - } - /** - * repeated string uuids = 1; - * @return The count of uuids. - */ - public int getUuidsCount() { - return uuids_.size(); - } - /** - * repeated string uuids = 1; - * @param index The index of the element to return. - * @return The uuids at the given index. - */ - public java.lang.String getUuids(int index) { - return uuids_.get(index); - } - /** - * repeated string uuids = 1; - * @param index The index of the value to return. - * @return The bytes of the uuids at the given index. - */ - public com.google.protobuf.ByteString - getUuidsBytes(int index) { - return uuids_.getByteString(index); - } - /** - * repeated string uuids = 1; - * @param index The index to set the value at. - * @param value The uuids to set. - * @return This builder for chaining. - */ - public Builder setUuids( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureUuidsIsMutable(); - uuids_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param value The uuids to add. - * @return This builder for chaining. - */ - public Builder addUuids( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureUuidsIsMutable(); - uuids_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param values The uuids to add. - * @return This builder for chaining. - */ - public Builder addAllUuids( - java.lang.Iterable values) { - ensureUuidsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, uuids_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @return This builder for chaining. - */ - public Builder clearUuids() { - uuids_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string uuids = 1; - * @param value The bytes of the uuids to add. - * @return This builder for chaining. - */ - public Builder addUuidsBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureUuidsIsMutable(); - uuids_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string prop_name = 2; - * @param value The propName to set. - * @return This builder for chaining. - */ - public Builder setPropName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @return This builder for chaining. - */ - public Builder clearPropName() { - propName_ = getDefaultInstance().getPropName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @param value The bytes for propName to set. - * @return This builder for chaining. - */ - public Builder setPropNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 3; - * @return The targetCollection. - */ - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string target_collection = 3; - * @param value The targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - targetCollection_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string target_collection = 3; - * @return This builder for chaining. - */ - public Builder clearTargetCollection() { - targetCollection_ = getDefaultInstance().getTargetCollection(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string target_collection = 3; - * @param value The bytes for targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - targetCollection_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.MultiTargetRefProps) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.MultiTargetRefProps) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public MultiTargetRefProps parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private int bitField0_; - public static final int UUID_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object uuid_ = ""; - /** - * string uuid = 1; - * @return The uuid. - */ - @java.lang.Override - public java.lang.String getUuid() { - java.lang.Object ref = uuid_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - uuid_ = s; - return s; - } - } - /** - * string uuid = 1; - * @return The bytes for uuid. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getUuidBytes() { - java.lang.Object ref = uuid_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - uuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int VECTOR_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private com.google.protobuf.Internal.FloatList vector_ = - emptyFloatList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return A list containing the vector. - */ - @java.lang.Override - @java.lang.Deprecated public java.util.List - getVectorList() { - return vector_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return The count of vector. - */ - @java.lang.Deprecated public int getVectorCount() { - return vector_.size(); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated public float getVector(int index) { - return vector_.getFloat(index); - } - private int vectorMemoizedSerializedSize = -1; - - public static final int PROPERTIES_FIELD_NUMBER = 3; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties properties_; - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return Whether the properties field is set. - */ - @java.lang.Override - public boolean hasProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return The properties. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getProperties() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; - } - - public static final int COLLECTION_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private volatile java.lang.Object collection_ = ""; - /** - * string collection = 4; - * @return The collection. - */ - @java.lang.Override - public java.lang.String getCollection() { - java.lang.Object ref = collection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - collection_ = s; - return s; - } - } - /** - * string collection = 4; - * @return The bytes for collection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getCollectionBytes() { - java.lang.Object ref = collection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - collection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TENANT_FIELD_NUMBER = 5; - @SuppressWarnings("serial") - private volatile java.lang.Object tenant_ = ""; - /** - * string tenant = 5; - * @return The tenant. - */ - @java.lang.Override - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } - } - /** - * string tenant = 5; - * @return The bytes for tenant. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int VECTOR_BYTES_FIELD_NUMBER = 6; - private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes vector_bytes = 6; - * @return The vectorBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getVectorBytes() { - return vectorBytes_; - } - - public static final int VECTORS_FIELD_NUMBER = 23; - @SuppressWarnings("serial") - private java.util.List vectors_; - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public java.util.List getVectorsList() { - return vectors_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public java.util.List - getVectorsOrBuilderList() { - return vectors_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public int getVectorsCount() { - return vectors_.size(); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) { - return vectors_.get(index); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index) { - return vectors_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getSerializedSize(); - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(uuid_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuid_); - } - if (getVectorList().size() > 0) { - output.writeUInt32NoTag(18); - output.writeUInt32NoTag(vectorMemoizedSerializedSize); - } - for (int i = 0; i < vector_.size(); i++) { - output.writeFloatNoTag(vector_.getFloat(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(3, getProperties()); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 4, collection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 5, tenant_); - } - if (!vectorBytes_.isEmpty()) { - output.writeBytes(6, vectorBytes_); - } - for (int i = 0; i < vectors_.size(); i++) { - output.writeMessage(23, vectors_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(uuid_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, uuid_); - } - { - int dataSize = 0; - dataSize = 4 * getVectorList().size(); - size += dataSize; - if (!getVectorList().isEmpty()) { - size += 1; - size += com.google.protobuf.CodedOutputStream - .computeInt32SizeNoTag(dataSize); - } - vectorMemoizedSerializedSize = dataSize; - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, getProperties()); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, collection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, tenant_); - } - if (!vectorBytes_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(6, vectorBytes_); - } - for (int i = 0; i < vectors_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(23, vectors_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject) obj; - - if (!getUuid() - .equals(other.getUuid())) return false; - if (!getVectorList() - .equals(other.getVectorList())) return false; - if (hasProperties() != other.hasProperties()) return false; - if (hasProperties()) { - if (!getProperties() - .equals(other.getProperties())) return false; - } - if (!getCollection() - .equals(other.getCollection())) return false; - if (!getTenant() - .equals(other.getTenant())) return false; - if (!getVectorBytes() - .equals(other.getVectorBytes())) return false; - if (!getVectorsList() - .equals(other.getVectorsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + UUID_FIELD_NUMBER; - hash = (53 * hash) + getUuid().hashCode(); - if (getVectorCount() > 0) { - hash = (37 * hash) + VECTOR_FIELD_NUMBER; - hash = (53 * hash) + getVectorList().hashCode(); - } - if (hasProperties()) { - hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getProperties().hashCode(); - } - hash = (37 * hash) + COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getCollection().hashCode(); - hash = (37 * hash) + TENANT_FIELD_NUMBER; - hash = (53 * hash) + getTenant().hashCode(); - hash = (37 * hash) + VECTOR_BYTES_FIELD_NUMBER; - hash = (53 * hash) + getVectorBytes().hashCode(); - if (getVectorsCount() > 0) { - hash = (37 * hash) + VECTORS_FIELD_NUMBER; - hash = (53 * hash) + getVectorsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObject} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getPropertiesFieldBuilder(); - getVectorsFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - uuid_ = ""; - vector_ = emptyFloatList(); - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - collection_ = ""; - tenant_ = ""; - vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - if (vectorsBuilder_ == null) { - vectors_ = java.util.Collections.emptyList(); - } else { - vectors_ = null; - vectorsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000040); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject result) { - if (vectorsBuilder_ == null) { - if (((bitField0_ & 0x00000040) != 0)) { - vectors_ = java.util.Collections.unmodifiableList(vectors_); - bitField0_ = (bitField0_ & ~0x00000040); - } - result.vectors_ = vectors_; - } else { - result.vectors_ = vectorsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.uuid_ = uuid_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - vector_.makeImmutable(); - result.vector_ = vector_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000004) != 0)) { - result.properties_ = propertiesBuilder_ == null - ? properties_ - : propertiesBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.collection_ = collection_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.tenant_ = tenant_; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.vectorBytes_ = vectorBytes_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.getDefaultInstance()) return this; - if (!other.getUuid().isEmpty()) { - uuid_ = other.uuid_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.vector_.isEmpty()) { - if (vector_.isEmpty()) { - vector_ = other.vector_; - vector_.makeImmutable(); - bitField0_ |= 0x00000002; - } else { - ensureVectorIsMutable(); - vector_.addAll(other.vector_); - } - onChanged(); - } - if (other.hasProperties()) { - mergeProperties(other.getProperties()); - } - if (!other.getCollection().isEmpty()) { - collection_ = other.collection_; - bitField0_ |= 0x00000008; - onChanged(); - } - if (!other.getTenant().isEmpty()) { - tenant_ = other.tenant_; - bitField0_ |= 0x00000010; - onChanged(); - } - if (other.getVectorBytes() != com.google.protobuf.ByteString.EMPTY) { - setVectorBytes(other.getVectorBytes()); - } - if (vectorsBuilder_ == null) { - if (!other.vectors_.isEmpty()) { - if (vectors_.isEmpty()) { - vectors_ = other.vectors_; - bitField0_ = (bitField0_ & ~0x00000040); - } else { - ensureVectorsIsMutable(); - vectors_.addAll(other.vectors_); - } - onChanged(); - } - } else { - if (!other.vectors_.isEmpty()) { - if (vectorsBuilder_.isEmpty()) { - vectorsBuilder_.dispose(); - vectorsBuilder_ = null; - vectors_ = other.vectors_; - bitField0_ = (bitField0_ & ~0x00000040); - vectorsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getVectorsFieldBuilder() : null; - } else { - vectorsBuilder_.addAllMessages(other.vectors_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - uuid_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 21: { - float v = input.readFloat(); - ensureVectorIsMutable(); - vector_.addFloat(v); - break; - } // case 21 - case 18: { - int length = input.readRawVarint32(); - int limit = input.pushLimit(length); - int alloc = length > 4096 ? 4096 : length; - ensureVectorIsMutable(alloc / 4); - while (input.getBytesUntilLimit() > 0) { - vector_.addFloat(input.readFloat()); - } - input.popLimit(limit); - break; - } // case 18 - case 26: { - input.readMessage( - getPropertiesFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 34: { - collection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000008; - break; - } // case 34 - case 42: { - tenant_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000010; - break; - } // case 42 - case 50: { - vectorBytes_ = input.readBytes(); - bitField0_ |= 0x00000020; - break; - } // case 50 - case 186: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.parser(), - extensionRegistry); - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(m); - } else { - vectorsBuilder_.addMessage(m); - } - break; - } // case 186 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object uuid_ = ""; - /** - * string uuid = 1; - * @return The uuid. - */ - public java.lang.String getUuid() { - java.lang.Object ref = uuid_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - uuid_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string uuid = 1; - * @return The bytes for uuid. - */ - public com.google.protobuf.ByteString - getUuidBytes() { - java.lang.Object ref = uuid_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - uuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string uuid = 1; - * @param value The uuid to set. - * @return This builder for chaining. - */ - public Builder setUuid( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - uuid_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string uuid = 1; - * @return This builder for chaining. - */ - public Builder clearUuid() { - uuid_ = getDefaultInstance().getUuid(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string uuid = 1; - * @param value The bytes for uuid to set. - * @return This builder for chaining. - */ - public Builder setUuidBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - uuid_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private com.google.protobuf.Internal.FloatList vector_ = emptyFloatList(); - private void ensureVectorIsMutable() { - if (!vector_.isModifiable()) { - vector_ = makeMutableCopy(vector_); - } - bitField0_ |= 0x00000002; - } - private void ensureVectorIsMutable(int capacity) { - if (!vector_.isModifiable()) { - vector_ = makeMutableCopy(vector_, capacity); - } - bitField0_ |= 0x00000002; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return A list containing the vector. - */ - @java.lang.Deprecated public java.util.List - getVectorList() { - vector_.makeImmutable(); - return vector_; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return The count of vector. - */ - @java.lang.Deprecated public int getVectorCount() { - return vector_.size(); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated public float getVector(int index) { - return vector_.getFloat(index); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param index The index to set the value at. - * @param value The vector to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setVector( - int index, float value) { - - ensureVectorIsMutable(); - vector_.setFloat(index, value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param value The vector to add. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder addVector(float value) { - - ensureVectorIsMutable(); - vector_.addFloat(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @param values The vector to add. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder addAllVector( - java.lang.Iterable values) { - ensureVectorIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, vector_); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.BatchObject.vector is deprecated. - * See v1/batch.proto;l=104 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearVector() { - vector_ = emptyFloatList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties properties_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder> propertiesBuilder_; - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return Whether the properties field is set. - */ - public boolean hasProperties() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - * @return The properties. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties getProperties() { - if (propertiesBuilder_ == null) { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; - } else { - return propertiesBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - properties_ = value; - } else { - propertiesBuilder_.setMessage(value); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public Builder setProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder builderForValue) { - if (propertiesBuilder_ == null) { - properties_ = builderForValue.build(); - } else { - propertiesBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public Builder mergeProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties value) { - if (propertiesBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0) && - properties_ != null && - properties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance()) { - getPropertiesBuilder().mergeFrom(value); - } else { - properties_ = value; - } - } else { - propertiesBuilder_.mergeFrom(value); - } - if (properties_ != null) { - bitField0_ |= 0x00000004; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public Builder clearProperties() { - bitField0_ = (bitField0_ & ~0x00000004); - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder getPropertiesBuilder() { - bitField0_ |= 0x00000004; - onChanged(); - return getPropertiesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder() { - if (propertiesBuilder_ != null) { - return propertiesBuilder_.getMessageOrBuilder(); - } else { - return properties_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; - } - } - /** - * .weaviate.v1.BatchObject.Properties properties = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder> - getPropertiesFieldBuilder() { - if (propertiesBuilder_ == null) { - propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder>( - getProperties(), - getParentForChildren(), - isClean()); - properties_ = null; - } - return propertiesBuilder_; - } - - private java.lang.Object collection_ = ""; - /** - * string collection = 4; - * @return The collection. - */ - public java.lang.String getCollection() { - java.lang.Object ref = collection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - collection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string collection = 4; - * @return The bytes for collection. - */ - public com.google.protobuf.ByteString - getCollectionBytes() { - java.lang.Object ref = collection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - collection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string collection = 4; - * @param value The collection to set. - * @return This builder for chaining. - */ - public Builder setCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - collection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * string collection = 4; - * @return This builder for chaining. - */ - public Builder clearCollection() { - collection_ = getDefaultInstance().getCollection(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - return this; - } - /** - * string collection = 4; - * @param value The bytes for collection to set. - * @return This builder for chaining. - */ - public Builder setCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - collection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - - private java.lang.Object tenant_ = ""; - /** - * string tenant = 5; - * @return The tenant. - */ - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string tenant = 5; - * @return The bytes for tenant. - */ - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string tenant = 5; - * @param value The tenant to set. - * @return This builder for chaining. - */ - public Builder setTenant( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - tenant_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * string tenant = 5; - * @return This builder for chaining. - */ - public Builder clearTenant() { - tenant_ = getDefaultInstance().getTenant(); - bitField0_ = (bitField0_ & ~0x00000010); - onChanged(); - return this; - } - /** - * string tenant = 5; - * @param value The bytes for tenant to set. - * @return This builder for chaining. - */ - public Builder setTenantBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - tenant_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - - private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes vector_bytes = 6; - * @return The vectorBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getVectorBytes() { - return vectorBytes_; - } - /** - * bytes vector_bytes = 6; - * @param value The vectorBytes to set. - * @return This builder for chaining. - */ - public Builder setVectorBytes(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - vectorBytes_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * bytes vector_bytes = 6; - * @return This builder for chaining. - */ - public Builder clearVectorBytes() { - bitField0_ = (bitField0_ & ~0x00000020); - vectorBytes_ = getDefaultInstance().getVectorBytes(); - onChanged(); - return this; - } - - private java.util.List vectors_ = - java.util.Collections.emptyList(); - private void ensureVectorsIsMutable() { - if (!((bitField0_ & 0x00000040) != 0)) { - vectors_ = new java.util.ArrayList(vectors_); - bitField0_ |= 0x00000040; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_; - - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List getVectorsList() { - if (vectorsBuilder_ == null) { - return java.util.Collections.unmodifiableList(vectors_); - } else { - return vectorsBuilder_.getMessageList(); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public int getVectorsCount() { - if (vectorsBuilder_ == null) { - return vectors_.size(); - } else { - return vectorsBuilder_.getCount(); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) { - if (vectorsBuilder_ == null) { - return vectors_.get(index); - } else { - return vectorsBuilder_.getMessage(index); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder setVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.set(index, value); - onChanged(); - } else { - vectorsBuilder_.setMessage(index, value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder setVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.set(index, builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.add(value); - onChanged(); - } else { - vectorsBuilder_.addMessage(value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.add(index, value); - onChanged(); - } else { - vectorsBuilder_.addMessage(index, value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(index, builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addAllVectors( - java.lang.Iterable values) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, vectors_); - onChanged(); - } else { - vectorsBuilder_.addAllMessages(values); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder clearVectors() { - if (vectorsBuilder_ == null) { - vectors_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000040); - onChanged(); - } else { - vectorsBuilder_.clear(); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder removeVectors(int index) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.remove(index); - onChanged(); - } else { - vectorsBuilder_.remove(index); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder getVectorsBuilder( - int index) { - return getVectorsFieldBuilder().getBuilder(index); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index) { - if (vectorsBuilder_ == null) { - return vectors_.get(index); } else { - return vectorsBuilder_.getMessageOrBuilder(index); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List - getVectorsOrBuilderList() { - if (vectorsBuilder_ != null) { - return vectorsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(vectors_); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() { - return getVectorsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance()); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder( - int index) { - return getVectorsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance()); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List - getVectorsBuilderList() { - return getVectorsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> - getVectorsFieldBuilder() { - if (vectorsBuilder_ == null) { - vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder>( - vectors_, - ((bitField0_ & 0x00000040) != 0), - getParentForChildren(), - isClean()); - vectors_ = null; - } - return vectorsBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchObject parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObject getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchReferenceOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReference) - com.google.protobuf.MessageOrBuilder { - - /** - * string name = 1; - * @return The name. - */ - java.lang.String getName(); - /** - * string name = 1; - * @return The bytes for name. - */ - com.google.protobuf.ByteString - getNameBytes(); - - /** - * string from_collection = 2; - * @return The fromCollection. - */ - java.lang.String getFromCollection(); - /** - * string from_collection = 2; - * @return The bytes for fromCollection. - */ - com.google.protobuf.ByteString - getFromCollectionBytes(); - - /** - * string from_uuid = 3; - * @return The fromUuid. - */ - java.lang.String getFromUuid(); - /** - * string from_uuid = 3; - * @return The bytes for fromUuid. - */ - com.google.protobuf.ByteString - getFromUuidBytes(); - - /** - * optional string to_collection = 4; - * @return Whether the toCollection field is set. - */ - boolean hasToCollection(); - /** - * optional string to_collection = 4; - * @return The toCollection. - */ - java.lang.String getToCollection(); - /** - * optional string to_collection = 4; - * @return The bytes for toCollection. - */ - com.google.protobuf.ByteString - getToCollectionBytes(); - - /** - * string to_uuid = 5; - * @return The toUuid. - */ - java.lang.String getToUuid(); - /** - * string to_uuid = 5; - * @return The bytes for toUuid. - */ - com.google.protobuf.ByteString - getToUuidBytes(); - - /** - * string tenant = 6; - * @return The tenant. - */ - java.lang.String getTenant(); - /** - * string tenant = 6; - * @return The bytes for tenant. - */ - com.google.protobuf.ByteString - getTenantBytes(); - } - /** - * Protobuf type {@code weaviate.v1.BatchReference} - */ - public static final class BatchReference extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReference) - BatchReferenceOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchReference.newBuilder() to construct. - private BatchReference(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchReference() { - name_ = ""; - fromCollection_ = ""; - fromUuid_ = ""; - toCollection_ = ""; - toUuid_ = ""; - tenant_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchReference(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder.class); - } - - private int bitField0_; - public static final int NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object name_ = ""; - /** - * string name = 1; - * @return The name. - */ - @java.lang.Override - public java.lang.String getName() { - java.lang.Object ref = name_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - name_ = s; - return s; - } - } - /** - * string name = 1; - * @return The bytes for name. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getNameBytes() { - java.lang.Object ref = name_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - name_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FROM_COLLECTION_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object fromCollection_ = ""; - /** - * string from_collection = 2; - * @return The fromCollection. - */ - @java.lang.Override - public java.lang.String getFromCollection() { - java.lang.Object ref = fromCollection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fromCollection_ = s; - return s; - } - } - /** - * string from_collection = 2; - * @return The bytes for fromCollection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFromCollectionBytes() { - java.lang.Object ref = fromCollection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fromCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FROM_UUID_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fromUuid_ = ""; - /** - * string from_uuid = 3; - * @return The fromUuid. - */ - @java.lang.Override - public java.lang.String getFromUuid() { - java.lang.Object ref = fromUuid_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fromUuid_ = s; - return s; - } - } - /** - * string from_uuid = 3; - * @return The bytes for fromUuid. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFromUuidBytes() { - java.lang.Object ref = fromUuid_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fromUuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TO_COLLECTION_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private volatile java.lang.Object toCollection_ = ""; - /** - * optional string to_collection = 4; - * @return Whether the toCollection field is set. - */ - @java.lang.Override - public boolean hasToCollection() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional string to_collection = 4; - * @return The toCollection. - */ - @java.lang.Override - public java.lang.String getToCollection() { - java.lang.Object ref = toCollection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - toCollection_ = s; - return s; - } - } - /** - * optional string to_collection = 4; - * @return The bytes for toCollection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getToCollectionBytes() { - java.lang.Object ref = toCollection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - toCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TO_UUID_FIELD_NUMBER = 5; - @SuppressWarnings("serial") - private volatile java.lang.Object toUuid_ = ""; - /** - * string to_uuid = 5; - * @return The toUuid. - */ - @java.lang.Override - public java.lang.String getToUuid() { - java.lang.Object ref = toUuid_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - toUuid_ = s; - return s; - } - } - /** - * string to_uuid = 5; - * @return The bytes for toUuid. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getToUuidBytes() { - java.lang.Object ref = toUuid_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - toUuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TENANT_FIELD_NUMBER = 6; - @SuppressWarnings("serial") - private volatile java.lang.Object tenant_ = ""; - /** - * string tenant = 6; - * @return The tenant. - */ - @java.lang.Override - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } - } - /** - * string tenant = 6; - * @return The bytes for tenant. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromCollection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, fromCollection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromUuid_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fromUuid_); - } - if (((bitField0_ & 0x00000001) != 0)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 4, toCollection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(toUuid_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 5, toUuid_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 6, tenant_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromCollection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, fromCollection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromUuid_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fromUuid_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, toCollection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(toUuid_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, toUuid_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, tenant_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference) obj; - - if (!getName() - .equals(other.getName())) return false; - if (!getFromCollection() - .equals(other.getFromCollection())) return false; - if (!getFromUuid() - .equals(other.getFromUuid())) return false; - if (hasToCollection() != other.hasToCollection()) return false; - if (hasToCollection()) { - if (!getToCollection() - .equals(other.getToCollection())) return false; - } - if (!getToUuid() - .equals(other.getToUuid())) return false; - if (!getTenant() - .equals(other.getTenant())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + NAME_FIELD_NUMBER; - hash = (53 * hash) + getName().hashCode(); - hash = (37 * hash) + FROM_COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getFromCollection().hashCode(); - hash = (37 * hash) + FROM_UUID_FIELD_NUMBER; - hash = (53 * hash) + getFromUuid().hashCode(); - if (hasToCollection()) { - hash = (37 * hash) + TO_COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getToCollection().hashCode(); - } - hash = (37 * hash) + TO_UUID_FIELD_NUMBER; - hash = (53 * hash) + getToUuid().hashCode(); - hash = (37 * hash) + TENANT_FIELD_NUMBER; - hash = (53 * hash) + getTenant().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchReference} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReference) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferenceOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - name_ = ""; - fromCollection_ = ""; - fromUuid_ = ""; - toCollection_ = ""; - toUuid_ = ""; - tenant_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.name_ = name_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.fromCollection_ = fromCollection_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fromUuid_ = fromUuid_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000008) != 0)) { - result.toCollection_ = toCollection_; - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.toUuid_ = toUuid_; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.tenant_ = tenant_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference.getDefaultInstance()) return this; - if (!other.getName().isEmpty()) { - name_ = other.name_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getFromCollection().isEmpty()) { - fromCollection_ = other.fromCollection_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFromUuid().isEmpty()) { - fromUuid_ = other.fromUuid_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (other.hasToCollection()) { - toCollection_ = other.toCollection_; - bitField0_ |= 0x00000008; - onChanged(); - } - if (!other.getToUuid().isEmpty()) { - toUuid_ = other.toUuid_; - bitField0_ |= 0x00000010; - onChanged(); - } - if (!other.getTenant().isEmpty()) { - tenant_ = other.tenant_; - bitField0_ |= 0x00000020; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - name_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - fromCollection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fromUuid_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 34: { - toCollection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000008; - break; - } // case 34 - case 42: { - toUuid_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000010; - break; - } // case 42 - case 50: { - tenant_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000020; - break; - } // case 50 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object name_ = ""; - /** - * string name = 1; - * @return The name. - */ - public java.lang.String getName() { - java.lang.Object ref = name_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - name_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string name = 1; - * @return The bytes for name. - */ - public com.google.protobuf.ByteString - getNameBytes() { - java.lang.Object ref = name_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - name_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string name = 1; - * @param value The name to set. - * @return This builder for chaining. - */ - public Builder setName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - name_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string name = 1; - * @return This builder for chaining. - */ - public Builder clearName() { - name_ = getDefaultInstance().getName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string name = 1; - * @param value The bytes for name to set. - * @return This builder for chaining. - */ - public Builder setNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - name_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object fromCollection_ = ""; - /** - * string from_collection = 2; - * @return The fromCollection. - */ - public java.lang.String getFromCollection() { - java.lang.Object ref = fromCollection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fromCollection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string from_collection = 2; - * @return The bytes for fromCollection. - */ - public com.google.protobuf.ByteString - getFromCollectionBytes() { - java.lang.Object ref = fromCollection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fromCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string from_collection = 2; - * @param value The fromCollection to set. - * @return This builder for chaining. - */ - public Builder setFromCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fromCollection_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string from_collection = 2; - * @return This builder for chaining. - */ - public Builder clearFromCollection() { - fromCollection_ = getDefaultInstance().getFromCollection(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string from_collection = 2; - * @param value The bytes for fromCollection to set. - * @return This builder for chaining. - */ - public Builder setFromCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fromCollection_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fromUuid_ = ""; - /** - * string from_uuid = 3; - * @return The fromUuid. - */ - public java.lang.String getFromUuid() { - java.lang.Object ref = fromUuid_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fromUuid_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string from_uuid = 3; - * @return The bytes for fromUuid. - */ - public com.google.protobuf.ByteString - getFromUuidBytes() { - java.lang.Object ref = fromUuid_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fromUuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string from_uuid = 3; - * @param value The fromUuid to set. - * @return This builder for chaining. - */ - public Builder setFromUuid( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fromUuid_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string from_uuid = 3; - * @return This builder for chaining. - */ - public Builder clearFromUuid() { - fromUuid_ = getDefaultInstance().getFromUuid(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string from_uuid = 3; - * @param value The bytes for fromUuid to set. - * @return This builder for chaining. - */ - public Builder setFromUuidBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fromUuid_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private java.lang.Object toCollection_ = ""; - /** - * optional string to_collection = 4; - * @return Whether the toCollection field is set. - */ - public boolean hasToCollection() { - return ((bitField0_ & 0x00000008) != 0); - } - /** - * optional string to_collection = 4; - * @return The toCollection. - */ - public java.lang.String getToCollection() { - java.lang.Object ref = toCollection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - toCollection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * optional string to_collection = 4; - * @return The bytes for toCollection. - */ - public com.google.protobuf.ByteString - getToCollectionBytes() { - java.lang.Object ref = toCollection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - toCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * optional string to_collection = 4; - * @param value The toCollection to set. - * @return This builder for chaining. - */ - public Builder setToCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - toCollection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * optional string to_collection = 4; - * @return This builder for chaining. - */ - public Builder clearToCollection() { - toCollection_ = getDefaultInstance().getToCollection(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - return this; - } - /** - * optional string to_collection = 4; - * @param value The bytes for toCollection to set. - * @return This builder for chaining. - */ - public Builder setToCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - toCollection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - - private java.lang.Object toUuid_ = ""; - /** - * string to_uuid = 5; - * @return The toUuid. - */ - public java.lang.String getToUuid() { - java.lang.Object ref = toUuid_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - toUuid_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string to_uuid = 5; - * @return The bytes for toUuid. - */ - public com.google.protobuf.ByteString - getToUuidBytes() { - java.lang.Object ref = toUuid_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - toUuid_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string to_uuid = 5; - * @param value The toUuid to set. - * @return This builder for chaining. - */ - public Builder setToUuid( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - toUuid_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * string to_uuid = 5; - * @return This builder for chaining. - */ - public Builder clearToUuid() { - toUuid_ = getDefaultInstance().getToUuid(); - bitField0_ = (bitField0_ & ~0x00000010); - onChanged(); - return this; - } - /** - * string to_uuid = 5; - * @param value The bytes for toUuid to set. - * @return This builder for chaining. - */ - public Builder setToUuidBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - toUuid_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - - private java.lang.Object tenant_ = ""; - /** - * string tenant = 6; - * @return The tenant. - */ - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string tenant = 6; - * @return The bytes for tenant. - */ - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string tenant = 6; - * @param value The tenant to set. - * @return This builder for chaining. - */ - public Builder setTenant( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - tenant_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * string tenant = 6; - * @return This builder for chaining. - */ - public Builder clearTenant() { - tenant_ = getDefaultInstance().getTenant(); - bitField0_ = (bitField0_ & ~0x00000020); - onChanged(); - return this; - } - /** - * string tenant = 6; - * @param value The bytes for tenant to set. - * @return This builder for chaining. - */ - public Builder setTenantBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - tenant_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReference) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReference) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchReference parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReference getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchObjectsReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsReply) - com.google.protobuf.MessageOrBuilder { - - /** - * float took = 1; - * @return The took. - */ - float getTook(); - - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - java.util.List - getErrorsList(); - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index); - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - int getErrorsCount(); - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - java.util.List - getErrorsOrBuilderList(); - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsReply} - */ - public static final class BatchObjectsReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsReply) - BatchObjectsReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchObjectsReply.newBuilder() to construct. - private BatchObjectsReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchObjectsReply() { - errors_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchObjectsReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.Builder.class); - } - - public interface BatchErrorOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsReply.BatchError) - com.google.protobuf.MessageOrBuilder { - - /** - * int32 index = 1; - * @return The index. - */ - int getIndex(); - - /** - * string error = 2; - * @return The error. - */ - java.lang.String getError(); - /** - * string error = 2; - * @return The bytes for error. - */ - com.google.protobuf.ByteString - getErrorBytes(); - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsReply.BatchError} - */ - public static final class BatchError extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsReply.BatchError) - BatchErrorOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchError.newBuilder() to construct. - private BatchError(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchError() { - error_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchError(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder.class); - } - - public static final int INDEX_FIELD_NUMBER = 1; - private int index_ = 0; - /** - * int32 index = 1; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - - public static final int ERROR_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object error_ = ""; - /** - * string error = 2; - * @return The error. - */ - @java.lang.Override - public java.lang.String getError() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } - } - /** - * string error = 2; - * @return The bytes for error. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (index_ != 0) { - output.writeInt32(1, index_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, error_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (index_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(1, index_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, error_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError) obj; - - if (getIndex() - != other.getIndex()) return false; - if (!getError() - .equals(other.getError())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_FIELD_NUMBER; - hash = (53 * hash) + getIndex(); - hash = (37 * hash) + ERROR_FIELD_NUMBER; - hash = (53 * hash) + getError().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsReply.BatchError} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsReply.BatchError) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - index_ = 0; - error_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.index_ = index_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.error_ = error_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()) return this; - if (other.getIndex() != 0) { - setIndex(other.getIndex()); - } - if (!other.getError().isEmpty()) { - error_ = other.error_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - index_ = input.readInt32(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - error_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private int index_ ; - /** - * int32 index = 1; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - /** - * int32 index = 1; - * @param value The index to set. - * @return This builder for chaining. - */ - public Builder setIndex(int value) { - - index_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * int32 index = 1; - * @return This builder for chaining. - */ - public Builder clearIndex() { - bitField0_ = (bitField0_ & ~0x00000001); - index_ = 0; - onChanged(); - return this; - } - - private java.lang.Object error_ = ""; - /** - * string error = 2; - * @return The error. - */ - public java.lang.String getError() { - java.lang.Object ref = error_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string error = 2; - * @return The bytes for error. - */ - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string error = 2; - * @param value The error to set. - * @return This builder for chaining. - */ - public Builder setError( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - error_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string error = 2; - * @return This builder for chaining. - */ - public Builder clearError() { - error_ = getDefaultInstance().getError(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string error = 2; - * @param value The bytes for error to set. - * @return This builder for chaining. - */ - public Builder setErrorBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - error_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsReply.BatchError) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsReply.BatchError) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchError parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public static final int TOOK_FIELD_NUMBER = 1; - private float took_ = 0F; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - - public static final int ERRORS_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List errors_; - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - @java.lang.Override - public java.util.List getErrorsList() { - return errors_; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - @java.lang.Override - public java.util.List - getErrorsOrBuilderList() { - return errors_; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - @java.lang.Override - public int getErrorsCount() { - return errors_.size(); - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index) { - return errors_.get(index); - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index) { - return errors_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - output.writeFloat(1, took_); - } - for (int i = 0; i < errors_.size(); i++) { - output.writeMessage(2, errors_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(1, took_); - } - for (int i = 0; i < errors_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, errors_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply) obj; - - if (java.lang.Float.floatToIntBits(getTook()) - != java.lang.Float.floatToIntBits( - other.getTook())) return false; - if (!getErrorsList() - .equals(other.getErrorsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + TOOK_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getTook()); - if (getErrorsCount() > 0) { - hash = (37 * hash) + ERRORS_FIELD_NUMBER; - hash = (53 * hash) + getErrorsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchObjectsReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - took_ = 0F; - if (errorsBuilder_ == null) { - errors_ = java.util.Collections.emptyList(); - } else { - errors_ = null; - errorsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000002); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply result) { - if (errorsBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0)) { - errors_ = java.util.Collections.unmodifiableList(errors_); - bitField0_ = (bitField0_ & ~0x00000002); - } - result.errors_ = errors_; - } else { - result.errors_ = errorsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.took_ = took_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance()) return this; - if (other.getTook() != 0F) { - setTook(other.getTook()); - } - if (errorsBuilder_ == null) { - if (!other.errors_.isEmpty()) { - if (errors_.isEmpty()) { - errors_ = other.errors_; - bitField0_ = (bitField0_ & ~0x00000002); - } else { - ensureErrorsIsMutable(); - errors_.addAll(other.errors_); - } - onChanged(); - } - } else { - if (!other.errors_.isEmpty()) { - if (errorsBuilder_.isEmpty()) { - errorsBuilder_.dispose(); - errorsBuilder_ = null; - errors_ = other.errors_; - bitField0_ = (bitField0_ & ~0x00000002); - errorsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getErrorsFieldBuilder() : null; - } else { - errorsBuilder_.addAllMessages(other.errors_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 13: { - took_ = input.readFloat(); - bitField0_ |= 0x00000001; - break; - } // case 13 - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.parser(), - extensionRegistry); - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(m); - } else { - errorsBuilder_.addMessage(m); - } - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private float took_ ; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - /** - * float took = 1; - * @param value The took to set. - * @return This builder for chaining. - */ - public Builder setTook(float value) { - - took_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * float took = 1; - * @return This builder for chaining. - */ - public Builder clearTook() { - bitField0_ = (bitField0_ & ~0x00000001); - took_ = 0F; - onChanged(); - return this; - } - - private java.util.List errors_ = - java.util.Collections.emptyList(); - private void ensureErrorsIsMutable() { - if (!((bitField0_ & 0x00000002) != 0)) { - errors_ = new java.util.ArrayList(errors_); - bitField0_ |= 0x00000002; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder> errorsBuilder_; - - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public java.util.List getErrorsList() { - if (errorsBuilder_ == null) { - return java.util.Collections.unmodifiableList(errors_); - } else { - return errorsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public int getErrorsCount() { - if (errorsBuilder_ == null) { - return errors_.size(); - } else { - return errorsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index) { - if (errorsBuilder_ == null) { - return errors_.get(index); - } else { - return errorsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder setErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.set(index, value); - onChanged(); - } else { - errorsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder setErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.set(index, builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder addErrors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.add(value); - onChanged(); - } else { - errorsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder addErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.add(index, value); - onChanged(); - } else { - errorsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder addErrors( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder addErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(index, builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder addAllErrors( - java.lang.Iterable values) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, errors_); - onChanged(); - } else { - errorsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder clearErrors() { - if (errorsBuilder_ == null) { - errors_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - } else { - errorsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public Builder removeErrors(int index) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.remove(index); - onChanged(); - } else { - errorsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder getErrorsBuilder( - int index) { - return getErrorsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index) { - if (errorsBuilder_ == null) { - return errors_.get(index); } else { - return errorsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public java.util.List - getErrorsOrBuilderList() { - if (errorsBuilder_ != null) { - return errorsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(errors_); - } - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder addErrorsBuilder() { - return getErrorsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder addErrorsBuilder( - int index) { - return getErrorsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; - */ - public java.util.List - getErrorsBuilderList() { - return getErrorsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder> - getErrorsFieldBuilder() { - if (errorsBuilder_ == null) { - errorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder>( - errors_, - ((bitField0_ & 0x00000002) != 0), - getParentForChildren(), - isClean()); - errors_ = null; - } - return errorsBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsReply) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchObjectsReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BatchReferencesReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesReply) - com.google.protobuf.MessageOrBuilder { - - /** - * float took = 1; - * @return The took. - */ - float getTook(); - - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - java.util.List - getErrorsList(); - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index); - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - int getErrorsCount(); - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - java.util.List - getErrorsOrBuilderList(); - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesReply} - */ - public static final class BatchReferencesReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesReply) - BatchReferencesReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchReferencesReply.newBuilder() to construct. - private BatchReferencesReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchReferencesReply() { - errors_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchReferencesReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.Builder.class); - } - - public interface BatchErrorOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesReply.BatchError) - com.google.protobuf.MessageOrBuilder { - - /** - * int32 index = 1; - * @return The index. - */ - int getIndex(); - - /** - * string error = 2; - * @return The error. - */ - java.lang.String getError(); - /** - * string error = 2; - * @return The bytes for error. - */ - com.google.protobuf.ByteString - getErrorBytes(); - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesReply.BatchError} - */ - public static final class BatchError extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesReply.BatchError) - BatchErrorOrBuilder { - private static final long serialVersionUID = 0L; - // Use BatchError.newBuilder() to construct. - private BatchError(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BatchError() { - error_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BatchError(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder.class); - } - - public static final int INDEX_FIELD_NUMBER = 1; - private int index_ = 0; - /** - * int32 index = 1; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - - public static final int ERROR_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object error_ = ""; - /** - * string error = 2; - * @return The error. - */ - @java.lang.Override - public java.lang.String getError() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } - } - /** - * string error = 2; - * @return The bytes for error. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (index_ != 0) { - output.writeInt32(1, index_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, error_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (index_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(1, index_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, error_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError) obj; - - if (getIndex() - != other.getIndex()) return false; - if (!getError() - .equals(other.getError())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_FIELD_NUMBER; - hash = (53 * hash) + getIndex(); - hash = (37 * hash) + ERROR_FIELD_NUMBER; - hash = (53 * hash) + getError().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesReply.BatchError} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesReply.BatchError) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - index_ = 0; - error_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.index_ = index_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.error_ = error_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()) return this; - if (other.getIndex() != 0) { - setIndex(other.getIndex()); - } - if (!other.getError().isEmpty()) { - error_ = other.error_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - index_ = input.readInt32(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - error_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private int index_ ; - /** - * int32 index = 1; - * @return The index. - */ - @java.lang.Override - public int getIndex() { - return index_; - } - /** - * int32 index = 1; - * @param value The index to set. - * @return This builder for chaining. - */ - public Builder setIndex(int value) { - - index_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * int32 index = 1; - * @return This builder for chaining. - */ - public Builder clearIndex() { - bitField0_ = (bitField0_ & ~0x00000001); - index_ = 0; - onChanged(); - return this; - } - - private java.lang.Object error_ = ""; - /** - * string error = 2; - * @return The error. - */ - public java.lang.String getError() { - java.lang.Object ref = error_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - error_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string error = 2; - * @return The bytes for error. - */ - public com.google.protobuf.ByteString - getErrorBytes() { - java.lang.Object ref = error_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - error_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string error = 2; - * @param value The error to set. - * @return This builder for chaining. - */ - public Builder setError( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - error_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string error = 2; - * @return This builder for chaining. - */ - public Builder clearError() { - error_ = getDefaultInstance().getError(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string error = 2; - * @param value The bytes for error to set. - * @return This builder for chaining. - */ - public Builder setErrorBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - error_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesReply.BatchError) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesReply.BatchError) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchError parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public static final int TOOK_FIELD_NUMBER = 1; - private float took_ = 0F; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - - public static final int ERRORS_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List errors_; - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - @java.lang.Override - public java.util.List getErrorsList() { - return errors_; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - @java.lang.Override - public java.util.List - getErrorsOrBuilderList() { - return errors_; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - @java.lang.Override - public int getErrorsCount() { - return errors_.size(); - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index) { - return errors_.get(index); - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index) { - return errors_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - output.writeFloat(1, took_); - } - for (int i = 0; i < errors_.size(); i++) { - output.writeMessage(2, errors_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(1, took_); - } - for (int i = 0; i < errors_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, errors_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply) obj; - - if (java.lang.Float.floatToIntBits(getTook()) - != java.lang.Float.floatToIntBits( - other.getTook())) return false; - if (!getErrorsList() - .equals(other.getErrorsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + TOOK_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getTook()); - if (getErrorsCount() > 0) { - hash = (37 * hash) + ERRORS_FIELD_NUMBER; - hash = (53 * hash) + getErrorsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BatchReferencesReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - took_ = 0F; - if (errorsBuilder_ == null) { - errors_ = java.util.Collections.emptyList(); - } else { - errors_ = null; - errorsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000002); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply result) { - if (errorsBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0)) { - errors_ = java.util.Collections.unmodifiableList(errors_); - bitField0_ = (bitField0_ & ~0x00000002); - } - result.errors_ = errors_; - } else { - result.errors_ = errorsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.took_ = took_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance()) return this; - if (other.getTook() != 0F) { - setTook(other.getTook()); - } - if (errorsBuilder_ == null) { - if (!other.errors_.isEmpty()) { - if (errors_.isEmpty()) { - errors_ = other.errors_; - bitField0_ = (bitField0_ & ~0x00000002); - } else { - ensureErrorsIsMutable(); - errors_.addAll(other.errors_); - } - onChanged(); - } - } else { - if (!other.errors_.isEmpty()) { - if (errorsBuilder_.isEmpty()) { - errorsBuilder_.dispose(); - errorsBuilder_ = null; - errors_ = other.errors_; - bitField0_ = (bitField0_ & ~0x00000002); - errorsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getErrorsFieldBuilder() : null; - } else { - errorsBuilder_.addAllMessages(other.errors_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 13: { - took_ = input.readFloat(); - bitField0_ |= 0x00000001; - break; - } // case 13 - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.parser(), - extensionRegistry); - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(m); - } else { - errorsBuilder_.addMessage(m); - } - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private float took_ ; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - /** - * float took = 1; - * @param value The took to set. - * @return This builder for chaining. - */ - public Builder setTook(float value) { - - took_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * float took = 1; - * @return This builder for chaining. - */ - public Builder clearTook() { - bitField0_ = (bitField0_ & ~0x00000001); - took_ = 0F; - onChanged(); - return this; - } - - private java.util.List errors_ = - java.util.Collections.emptyList(); - private void ensureErrorsIsMutable() { - if (!((bitField0_ & 0x00000002) != 0)) { - errors_ = new java.util.ArrayList(errors_); - bitField0_ |= 0x00000002; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder> errorsBuilder_; - - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public java.util.List getErrorsList() { - if (errorsBuilder_ == null) { - return java.util.Collections.unmodifiableList(errors_); - } else { - return errorsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public int getErrorsCount() { - if (errorsBuilder_ == null) { - return errors_.size(); - } else { - return errorsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index) { - if (errorsBuilder_ == null) { - return errors_.get(index); - } else { - return errorsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder setErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.set(index, value); - onChanged(); - } else { - errorsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder setErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.set(index, builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder addErrors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.add(value); - onChanged(); - } else { - errorsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder addErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { - if (errorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureErrorsIsMutable(); - errors_.add(index, value); - onChanged(); - } else { - errorsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder addErrors( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder addErrors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.add(index, builderForValue.build()); - onChanged(); - } else { - errorsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder addAllErrors( - java.lang.Iterable values) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, errors_); - onChanged(); - } else { - errorsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder clearErrors() { - if (errorsBuilder_ == null) { - errors_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - } else { - errorsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public Builder removeErrors(int index) { - if (errorsBuilder_ == null) { - ensureErrorsIsMutable(); - errors_.remove(index); - onChanged(); - } else { - errorsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder getErrorsBuilder( - int index) { - return getErrorsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( - int index) { - if (errorsBuilder_ == null) { - return errors_.get(index); } else { - return errorsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public java.util.List - getErrorsOrBuilderList() { - if (errorsBuilder_ != null) { - return errorsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(errors_); - } - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder addErrorsBuilder() { - return getErrorsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder addErrorsBuilder( - int index) { - return getErrorsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; - */ - public java.util.List - getErrorsBuilderList() { - return getErrorsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder> - getErrorsFieldBuilder() { - if (errorsBuilder_ == null) { - errorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder>( - errors_, - ((bitField0_ & 0x00000002) != 0), - getParentForChildren(), - isClean()); - errors_ = null; - } - return errorsBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesReply) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BatchReferencesReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchReferencesReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObjectsRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchReferencesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchSendRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchSendRequest_References_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchSendReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObject_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObject_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObject_Properties_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchReference_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchReference_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObjectsReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchReferencesReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\016v1/batch.proto\022\013weaviate.v1\032\034google/pr" + - "otobuf/struct.proto\032\rv1/base.proto\"\225\001\n\023B" + - "atchObjectsRequest\022)\n\007objects\030\001 \003(\0132\030.we" + - "aviate.v1.BatchObject\022=\n\021consistency_lev" + - "el\030\002 \001(\0162\035.weaviate.v1.ConsistencyLevelH" + - "\000\210\001\001B\024\n\022_consistency_level\"\236\001\n\026BatchRefe" + - "rencesRequest\022/\n\nreferences\030\001 \003(\0132\033.weav" + - "iate.v1.BatchReference\022=\n\021consistency_le" + - "vel\030\002 \001(\0162\035.weaviate.v1.ConsistencyLevel" + - "H\000\210\001\001B\024\n\022_consistency_level\"\326\002\n\020BatchSen" + - "dRequest\022\021\n\tstream_id\030\001 \001(\t\0228\n\007objects\030\002" + - " \001(\0132%.weaviate.v1.BatchSendRequest.Obje" + - "ctsH\000\022>\n\nreferences\030\003 \001(\0132(.weaviate.v1." + - "BatchSendRequest.ReferencesH\000\0222\n\004stop\030\004 " + - "\001(\0132\".weaviate.v1.BatchSendRequest.StopH" + - "\000\032\006\n\004Stop\0323\n\007Objects\022(\n\006values\030\001 \003(\0132\030.w" + - "eaviate.v1.BatchObject\0329\n\nReferences\022+\n\006" + - "values\030\001 \003(\0132\033.weaviate.v1.BatchReferenc" + - "eB\t\n\007message\"B\n\016BatchSendReply\022\027\n\017next_b" + - "atch_size\030\001 \001(\005\022\027\n\017backoff_seconds\030\002 \001(\002" + - "\"\307\001\n\022BatchStreamRequest\022=\n\021consistency_l" + - "evel\030\001 \001(\0162\035.weaviate.v1.ConsistencyLeve" + - "lH\000\210\001\001\022\031\n\014object_index\030\002 \001(\005H\001\210\001\001\022\034\n\017ref" + - "erence_index\030\003 \001(\005H\002\210\001\001B\024\n\022_consistency_" + - "levelB\017\n\r_object_indexB\022\n\020_reference_ind" + - "ex\"\360\003\n\022BatchStreamMessage\022\021\n\tstream_id\030\001" + - " \001(\t\0226\n\005error\030\002 \001(\0132%.weaviate.v1.BatchS" + - "treamMessage.ErrorH\000\0226\n\005start\030\003 \001(\0132%.we" + - "aviate.v1.BatchStreamMessage.StartH\000\0224\n\004" + - "stop\030\004 \001(\0132$.weaviate.v1.BatchStreamMess" + - "age.StopH\000\022<\n\010shutdown\030\005 \001(\0132(.weaviate." + - "v1.BatchStreamMessage.ShutdownH\000\022E\n\rshut" + - "ting_down\030\006 \001(\0132,.weaviate.v1.BatchStrea" + - "mMessage.ShuttingDownH\000\032\007\n\005Start\032\006\n\004Stop" + - "\032\n\n\010Shutdown\032\016\n\014ShuttingDown\032d\n\005Error\022\r\n" + - "\005error\030\001 \001(\t\022\r\n\005index\030\002 \001(\005\022\024\n\014is_retria" + - "ble\030\003 \001(\010\022\021\n\tis_object\030\004 \001(\010\022\024\n\014is_refer" + - "ence\030\005 \001(\010B\t\n\007message\"\336\007\n\013BatchObject\022\014\n" + - "\004uuid\030\001 \001(\t\022\022\n\006vector\030\002 \003(\002B\002\030\001\0227\n\nprope" + - "rties\030\003 \001(\0132#.weaviate.v1.BatchObject.Pr" + - "operties\022\022\n\ncollection\030\004 \001(\t\022\016\n\006tenant\030\005" + - " \001(\t\022\024\n\014vector_bytes\030\006 \001(\014\022%\n\007vectors\030\027 " + - "\003(\0132\024.weaviate.v1.Vectors\032\204\005\n\nProperties" + - "\0223\n\022non_ref_properties\030\001 \001(\0132\027.google.pr" + - "otobuf.Struct\022N\n\027single_target_ref_props" + - "\030\002 \003(\0132-.weaviate.v1.BatchObject.SingleT" + - "argetRefProps\022L\n\026multi_target_ref_props\030" + - "\003 \003(\0132,.weaviate.v1.BatchObject.MultiTar" + - "getRefProps\022C\n\027number_array_properties\030\004" + - " \003(\0132\".weaviate.v1.NumberArrayProperties" + - "\022=\n\024int_array_properties\030\005 \003(\0132\037.weaviat" + - "e.v1.IntArrayProperties\022?\n\025text_array_pr" + - "operties\030\006 \003(\0132 .weaviate.v1.TextArrayPr" + - "operties\022E\n\030boolean_array_properties\030\007 \003" + - "(\0132#.weaviate.v1.BooleanArrayProperties\022" + - "8\n\021object_properties\030\010 \003(\0132\035.weaviate.v1" + - ".ObjectProperties\022C\n\027object_array_proper" + - "ties\030\t \003(\0132\".weaviate.v1.ObjectArrayProp" + - "erties\022\030\n\020empty_list_props\030\n \003(\t\0328\n\024Sing" + - "leTargetRefProps\022\r\n\005uuids\030\001 \003(\t\022\021\n\tprop_" + - "name\030\002 \001(\t\032R\n\023MultiTargetRefProps\022\r\n\005uui" + - "ds\030\001 \003(\t\022\021\n\tprop_name\030\002 \001(\t\022\031\n\021target_co" + - "llection\030\003 \001(\t\"\231\001\n\016BatchReference\022\014\n\004nam" + - "e\030\001 \001(\t\022\027\n\017from_collection\030\002 \001(\t\022\021\n\tfrom" + - "_uuid\030\003 \001(\t\022\032\n\rto_collection\030\004 \001(\tH\000\210\001\001\022" + - "\017\n\007to_uuid\030\005 \001(\t\022\016\n\006tenant\030\006 \001(\tB\020\n\016_to_" + - "collection\"\210\001\n\021BatchObjectsReply\022\014\n\004took" + - "\030\001 \001(\002\0229\n\006errors\030\002 \003(\0132).weaviate.v1.Bat" + - "chObjectsReply.BatchError\032*\n\nBatchError\022" + - "\r\n\005index\030\001 \001(\005\022\r\n\005error\030\002 \001(\t\"\216\001\n\024BatchR" + - "eferencesReply\022\014\n\004took\030\001 \001(\002\022<\n\006errors\030\002" + - " \003(\0132,.weaviate.v1.BatchReferencesReply." + - "BatchError\032*\n\nBatchError\022\r\n\005index\030\001 \001(\005\022" + - "\r\n\005error\030\002 \001(\tBo\n#io.weaviate.client.grp" + - "c.protocol.v1B\022WeaviateProtoBatchZ4githu" + - "b.com/weaviate/weaviate/grpc/generated;p" + - "rotocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - com.google.protobuf.StructProto.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(), - }); - internal_static_weaviate_v1_BatchObjectsRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObjectsRequest_descriptor, - new java.lang.String[] { "Objects", "ConsistencyLevel", "ConsistencyLevel", }); - internal_static_weaviate_v1_BatchReferencesRequest_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchReferencesRequest_descriptor, - new java.lang.String[] { "References", "ConsistencyLevel", "ConsistencyLevel", }); - internal_static_weaviate_v1_BatchSendRequest_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchSendRequest_descriptor, - new java.lang.String[] { "StreamId", "Objects", "References", "Stop", "Message", }); - internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor = - internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor, - new java.lang.String[] { }); - internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor = - internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(1); - internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_BatchSendRequest_References_descriptor = - internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(2); - internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchSendRequest_References_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_BatchSendReply_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchSendReply_descriptor, - new java.lang.String[] { "NextBatchSize", "BackoffSeconds", }); - internal_static_weaviate_v1_BatchStreamRequest_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamRequest_descriptor, - new java.lang.String[] { "ConsistencyLevel", "ObjectIndex", "ReferenceIndex", "ConsistencyLevel", "ObjectIndex", "ReferenceIndex", }); - internal_static_weaviate_v1_BatchStreamMessage_descriptor = - getDescriptor().getMessageTypes().get(5); - internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_descriptor, - new java.lang.String[] { "StreamId", "Error", "Start", "Stop", "Shutdown", "ShuttingDown", "Message", }); - internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor = - internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor, - new java.lang.String[] { }); - internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor = - internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(1); - internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor, - new java.lang.String[] { }); - internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor = - internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(2); - internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor, - new java.lang.String[] { }); - internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor = - internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(3); - internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor, - new java.lang.String[] { }); - internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor = - internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(4); - internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor, - new java.lang.String[] { "Error", "Index", "IsRetriable", "IsObject", "IsReference", }); - internal_static_weaviate_v1_BatchObject_descriptor = - getDescriptor().getMessageTypes().get(6); - internal_static_weaviate_v1_BatchObject_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObject_descriptor, - new java.lang.String[] { "Uuid", "Vector", "Properties", "Collection", "Tenant", "VectorBytes", "Vectors", }); - internal_static_weaviate_v1_BatchObject_Properties_descriptor = - internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObject_Properties_descriptor, - new java.lang.String[] { "NonRefProperties", "SingleTargetRefProps", "MultiTargetRefProps", "NumberArrayProperties", "IntArrayProperties", "TextArrayProperties", "BooleanArrayProperties", "ObjectProperties", "ObjectArrayProperties", "EmptyListProps", }); - internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor = - internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(1); - internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor, - new java.lang.String[] { "Uuids", "PropName", }); - internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor = - internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(2); - internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor, - new java.lang.String[] { "Uuids", "PropName", "TargetCollection", }); - internal_static_weaviate_v1_BatchReference_descriptor = - getDescriptor().getMessageTypes().get(7); - internal_static_weaviate_v1_BatchReference_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchReference_descriptor, - new java.lang.String[] { "Name", "FromCollection", "FromUuid", "ToCollection", "ToUuid", "Tenant", "ToCollection", }); - internal_static_weaviate_v1_BatchObjectsReply_descriptor = - getDescriptor().getMessageTypes().get(8); - internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObjectsReply_descriptor, - new java.lang.String[] { "Took", "Errors", }); - internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor = - internal_static_weaviate_v1_BatchObjectsReply_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor, - new java.lang.String[] { "Index", "Error", }); - internal_static_weaviate_v1_BatchReferencesReply_descriptor = - getDescriptor().getMessageTypes().get(9); - internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchReferencesReply_descriptor, - new java.lang.String[] { "Took", "Errors", }); - internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor = - internal_static_weaviate_v1_BatchReferencesReply_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor, - new java.lang.String[] { "Index", "Error", }); - com.google.protobuf.StructProto.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoProperties.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoProperties.java deleted file mode 100644 index 3e2d6e342..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoProperties.java +++ /dev/null @@ -1,11614 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/properties.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateProtoProperties { - private WeaviateProtoProperties() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - public interface PropertiesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.Properties) - com.google.protobuf.MessageOrBuilder { - - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - int getFieldsCount(); - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - boolean containsFields( - java.lang.String key); - /** - * Use {@link #getFieldsMap()} instead. - */ - @java.lang.Deprecated - java.util.Map - getFields(); - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - java.util.Map - getFieldsMap(); - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrDefault( - java.lang.String key, - /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value defaultValue); - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrThrow( - java.lang.String key); - } - /** - * Protobuf type {@code weaviate.v1.Properties} - */ - public static final class Properties extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.Properties) - PropertiesOrBuilder { - private static final long serialVersionUID = 0L; - // Use Properties.newBuilder() to construct. - private Properties(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Properties() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Properties(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor; - } - - @SuppressWarnings({"rawtypes"}) - @java.lang.Override - protected com.google.protobuf.MapField internalGetMapField( - int number) { - switch (number) { - case 1: - return internalGetFields(); - default: - throw new RuntimeException( - "Invalid map field number: " + number); - } - } - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder.class); - } - - public static final int FIELDS_FIELD_NUMBER = 1; - private static final class FieldsDefaultEntryHolder { - static final com.google.protobuf.MapEntry< - java.lang.String, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value> defaultEntry = - com.google.protobuf.MapEntry - .newDefaultInstance( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_FieldsEntry_descriptor, - com.google.protobuf.WireFormat.FieldType.STRING, - "", - com.google.protobuf.WireFormat.FieldType.MESSAGE, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.getDefaultInstance()); - } - @SuppressWarnings("serial") - private com.google.protobuf.MapField< - java.lang.String, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value> fields_; - private com.google.protobuf.MapField - internalGetFields() { - if (fields_ == null) { - return com.google.protobuf.MapField.emptyMapField( - FieldsDefaultEntryHolder.defaultEntry); - } - return fields_; - } - public int getFieldsCount() { - return internalGetFields().getMap().size(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public boolean containsFields( - java.lang.String key) { - if (key == null) { throw new NullPointerException("map key"); } - return internalGetFields().getMap().containsKey(key); - } - /** - * Use {@link #getFieldsMap()} instead. - */ - @java.lang.Override - @java.lang.Deprecated - public java.util.Map getFields() { - return getFieldsMap(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public java.util.Map getFieldsMap() { - return internalGetFields().getMap(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrDefault( - java.lang.String key, - /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value defaultValue) { - if (key == null) { throw new NullPointerException("map key"); } - java.util.Map map = - internalGetFields().getMap(); - return map.containsKey(key) ? map.get(key) : defaultValue; - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrThrow( - java.lang.String key) { - if (key == null) { throw new NullPointerException("map key"); } - java.util.Map map = - internalGetFields().getMap(); - if (!map.containsKey(key)) { - throw new java.lang.IllegalArgumentException(); - } - return map.get(key); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - com.google.protobuf.GeneratedMessageV3 - .serializeStringMapTo( - output, - internalGetFields(), - FieldsDefaultEntryHolder.defaultEntry, - 1); - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (java.util.Map.Entry entry - : internalGetFields().getMap().entrySet()) { - com.google.protobuf.MapEntry - fields__ = FieldsDefaultEntryHolder.defaultEntry.newBuilderForType() - .setKey(entry.getKey()) - .setValue(entry.getValue()) - .build(); - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, fields__); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) obj; - - if (!internalGetFields().equals( - other.internalGetFields())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (!internalGetFields().getMap().isEmpty()) { - hash = (37 * hash) + FIELDS_FIELD_NUMBER; - hash = (53 * hash) + internalGetFields().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.Properties} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.Properties) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor; - } - - @SuppressWarnings({"rawtypes"}) - protected com.google.protobuf.MapField internalGetMapField( - int number) { - switch (number) { - case 1: - return internalGetFields(); - default: - throw new RuntimeException( - "Invalid map field number: " + number); - } - } - @SuppressWarnings({"rawtypes"}) - protected com.google.protobuf.MapField internalGetMutableMapField( - int number) { - switch (number) { - case 1: - return internalGetMutableFields(); - default: - throw new RuntimeException( - "Invalid map field number: " + number); - } - } - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - internalGetMutableFields().clear(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.fields_ = internalGetFields(); - result.fields_.makeImmutable(); - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance()) return this; - internalGetMutableFields().mergeFrom( - other.internalGetFields()); - bitField0_ |= 0x00000001; - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - com.google.protobuf.MapEntry - fields__ = input.readMessage( - FieldsDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); - internalGetMutableFields().getMutableMap().put( - fields__.getKey(), fields__.getValue()); - bitField0_ |= 0x00000001; - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.MapField< - java.lang.String, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value> fields_; - private com.google.protobuf.MapField - internalGetFields() { - if (fields_ == null) { - return com.google.protobuf.MapField.emptyMapField( - FieldsDefaultEntryHolder.defaultEntry); - } - return fields_; - } - private com.google.protobuf.MapField - internalGetMutableFields() { - if (fields_ == null) { - fields_ = com.google.protobuf.MapField.newMapField( - FieldsDefaultEntryHolder.defaultEntry); - } - if (!fields_.isMutable()) { - fields_ = fields_.copy(); - } - bitField0_ |= 0x00000001; - onChanged(); - return fields_; - } - public int getFieldsCount() { - return internalGetFields().getMap().size(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public boolean containsFields( - java.lang.String key) { - if (key == null) { throw new NullPointerException("map key"); } - return internalGetFields().getMap().containsKey(key); - } - /** - * Use {@link #getFieldsMap()} instead. - */ - @java.lang.Override - @java.lang.Deprecated - public java.util.Map getFields() { - return getFieldsMap(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public java.util.Map getFieldsMap() { - return internalGetFields().getMap(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrDefault( - java.lang.String key, - /* nullable */ -io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value defaultValue) { - if (key == null) { throw new NullPointerException("map key"); } - java.util.Map map = - internalGetFields().getMap(); - return map.containsKey(key) ? map.get(key) : defaultValue; - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getFieldsOrThrow( - java.lang.String key) { - if (key == null) { throw new NullPointerException("map key"); } - java.util.Map map = - internalGetFields().getMap(); - if (!map.containsKey(key)) { - throw new java.lang.IllegalArgumentException(); - } - return map.get(key); - } - public Builder clearFields() { - bitField0_ = (bitField0_ & ~0x00000001); - internalGetMutableFields().getMutableMap() - .clear(); - return this; - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - public Builder removeFields( - java.lang.String key) { - if (key == null) { throw new NullPointerException("map key"); } - internalGetMutableFields().getMutableMap() - .remove(key); - return this; - } - /** - * Use alternate mutation accessors instead. - */ - @java.lang.Deprecated - public java.util.Map - getMutableFields() { - bitField0_ |= 0x00000001; - return internalGetMutableFields().getMutableMap(); - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - public Builder putFields( - java.lang.String key, - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value value) { - if (key == null) { throw new NullPointerException("map key"); } - if (value == null) { throw new NullPointerException("map value"); } - internalGetMutableFields().getMutableMap() - .put(key, value); - bitField0_ |= 0x00000001; - return this; - } - /** - * map<string, .weaviate.v1.Value> fields = 1; - */ - public Builder putAllFields( - java.util.Map values) { - internalGetMutableFields().getMutableMap() - .putAll(values); - bitField0_ |= 0x00000001; - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.Properties) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.Properties) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Properties parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ValueOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.Value) - com.google.protobuf.MessageOrBuilder { - - /** - * double number_value = 1; - * @return Whether the numberValue field is set. - */ - boolean hasNumberValue(); - /** - * double number_value = 1; - * @return The numberValue. - */ - double getNumberValue(); - - /** - *
-     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-     * 
- * - * bool bool_value = 3; - * @return Whether the boolValue field is set. - */ - boolean hasBoolValue(); - /** - *
-     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-     * 
- * - * bool bool_value = 3; - * @return The boolValue. - */ - boolean getBoolValue(); - - /** - * .weaviate.v1.Properties object_value = 4; - * @return Whether the objectValue field is set. - */ - boolean hasObjectValue(); - /** - * .weaviate.v1.Properties object_value = 4; - * @return The objectValue. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getObjectValue(); - /** - * .weaviate.v1.Properties object_value = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder(); - - /** - * .weaviate.v1.ListValue list_value = 5; - * @return Whether the listValue field is set. - */ - boolean hasListValue(); - /** - * .weaviate.v1.ListValue list_value = 5; - * @return The listValue. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getListValue(); - /** - * .weaviate.v1.ListValue list_value = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder(); - - /** - * string date_value = 6; - * @return Whether the dateValue field is set. - */ - boolean hasDateValue(); - /** - * string date_value = 6; - * @return The dateValue. - */ - java.lang.String getDateValue(); - /** - * string date_value = 6; - * @return The bytes for dateValue. - */ - com.google.protobuf.ByteString - getDateValueBytes(); - - /** - * string uuid_value = 7; - * @return Whether the uuidValue field is set. - */ - boolean hasUuidValue(); - /** - * string uuid_value = 7; - * @return The uuidValue. - */ - java.lang.String getUuidValue(); - /** - * string uuid_value = 7; - * @return The bytes for uuidValue. - */ - com.google.protobuf.ByteString - getUuidValueBytes(); - - /** - * int64 int_value = 8; - * @return Whether the intValue field is set. - */ - boolean hasIntValue(); - /** - * int64 int_value = 8; - * @return The intValue. - */ - long getIntValue(); - - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return Whether the geoValue field is set. - */ - boolean hasGeoValue(); - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return The geoValue. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getGeoValue(); - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder(); - - /** - * string blob_value = 10; - * @return Whether the blobValue field is set. - */ - boolean hasBlobValue(); - /** - * string blob_value = 10; - * @return The blobValue. - */ - java.lang.String getBlobValue(); - /** - * string blob_value = 10; - * @return The bytes for blobValue. - */ - com.google.protobuf.ByteString - getBlobValueBytes(); - - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return Whether the phoneValue field is set. - */ - boolean hasPhoneValue(); - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return The phoneValue. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getPhoneValue(); - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder(); - - /** - * .google.protobuf.NullValue null_value = 12; - * @return Whether the nullValue field is set. - */ - boolean hasNullValue(); - /** - * .google.protobuf.NullValue null_value = 12; - * @return The enum numeric value on the wire for nullValue. - */ - int getNullValueValue(); - /** - * .google.protobuf.NullValue null_value = 12; - * @return The nullValue. - */ - com.google.protobuf.NullValue getNullValue(); - - /** - * string text_value = 13; - * @return Whether the textValue field is set. - */ - boolean hasTextValue(); - /** - * string text_value = 13; - * @return The textValue. - */ - java.lang.String getTextValue(); - /** - * string text_value = 13; - * @return The bytes for textValue. - */ - com.google.protobuf.ByteString - getTextValueBytes(); - - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.KindCase getKindCase(); - } - /** - * Protobuf type {@code weaviate.v1.Value} - */ - public static final class Value extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.Value) - ValueOrBuilder { - private static final long serialVersionUID = 0L; - // Use Value.newBuilder() to construct. - private Value(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Value() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Value(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Value_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.Builder.class); - } - - private int kindCase_ = 0; - @SuppressWarnings("serial") - private java.lang.Object kind_; - public enum KindCase - implements com.google.protobuf.Internal.EnumLite, - com.google.protobuf.AbstractMessage.InternalOneOfEnum { - NUMBER_VALUE(1), - BOOL_VALUE(3), - OBJECT_VALUE(4), - LIST_VALUE(5), - DATE_VALUE(6), - UUID_VALUE(7), - INT_VALUE(8), - GEO_VALUE(9), - BLOB_VALUE(10), - PHONE_VALUE(11), - NULL_VALUE(12), - TEXT_VALUE(13), - KIND_NOT_SET(0); - private final int value; - private KindCase(int value) { - this.value = value; - } - /** - * @param value The number of the enum to look for. - * @return The enum associated with the given number. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static KindCase valueOf(int value) { - return forNumber(value); - } - - public static KindCase forNumber(int value) { - switch (value) { - case 1: return NUMBER_VALUE; - case 3: return BOOL_VALUE; - case 4: return OBJECT_VALUE; - case 5: return LIST_VALUE; - case 6: return DATE_VALUE; - case 7: return UUID_VALUE; - case 8: return INT_VALUE; - case 9: return GEO_VALUE; - case 10: return BLOB_VALUE; - case 11: return PHONE_VALUE; - case 12: return NULL_VALUE; - case 13: return TEXT_VALUE; - case 0: return KIND_NOT_SET; - default: return null; - } - } - public int getNumber() { - return this.value; - } - }; - - public KindCase - getKindCase() { - return KindCase.forNumber( - kindCase_); - } - - public static final int NUMBER_VALUE_FIELD_NUMBER = 1; - /** - * double number_value = 1; - * @return Whether the numberValue field is set. - */ - @java.lang.Override - public boolean hasNumberValue() { - return kindCase_ == 1; - } - /** - * double number_value = 1; - * @return The numberValue. - */ - @java.lang.Override - public double getNumberValue() { - if (kindCase_ == 1) { - return (java.lang.Double) kind_; - } - return 0D; - } - - public static final int BOOL_VALUE_FIELD_NUMBER = 3; - /** - *
-     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-     * 
- * - * bool bool_value = 3; - * @return Whether the boolValue field is set. - */ - @java.lang.Override - public boolean hasBoolValue() { - return kindCase_ == 3; - } - /** - *
-     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-     * 
- * - * bool bool_value = 3; - * @return The boolValue. - */ - @java.lang.Override - public boolean getBoolValue() { - if (kindCase_ == 3) { - return (java.lang.Boolean) kind_; - } - return false; - } - - public static final int OBJECT_VALUE_FIELD_NUMBER = 4; - /** - * .weaviate.v1.Properties object_value = 4; - * @return Whether the objectValue field is set. - */ - @java.lang.Override - public boolean hasObjectValue() { - return kindCase_ == 4; - } - /** - * .weaviate.v1.Properties object_value = 4; - * @return The objectValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getObjectValue() { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder() { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - - public static final int LIST_VALUE_FIELD_NUMBER = 5; - /** - * .weaviate.v1.ListValue list_value = 5; - * @return Whether the listValue field is set. - */ - @java.lang.Override - public boolean hasListValue() { - return kindCase_ == 5; - } - /** - * .weaviate.v1.ListValue list_value = 5; - * @return The listValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getListValue() { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder() { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - - public static final int DATE_VALUE_FIELD_NUMBER = 6; - /** - * string date_value = 6; - * @return Whether the dateValue field is set. - */ - public boolean hasDateValue() { - return kindCase_ == 6; - } - /** - * string date_value = 6; - * @return The dateValue. - */ - public java.lang.String getDateValue() { - java.lang.Object ref = ""; - if (kindCase_ == 6) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 6) { - kind_ = s; - } - return s; - } - } - /** - * string date_value = 6; - * @return The bytes for dateValue. - */ - public com.google.protobuf.ByteString - getDateValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 6) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 6) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int UUID_VALUE_FIELD_NUMBER = 7; - /** - * string uuid_value = 7; - * @return Whether the uuidValue field is set. - */ - public boolean hasUuidValue() { - return kindCase_ == 7; - } - /** - * string uuid_value = 7; - * @return The uuidValue. - */ - public java.lang.String getUuidValue() { - java.lang.Object ref = ""; - if (kindCase_ == 7) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 7) { - kind_ = s; - } - return s; - } - } - /** - * string uuid_value = 7; - * @return The bytes for uuidValue. - */ - public com.google.protobuf.ByteString - getUuidValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 7) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 7) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int INT_VALUE_FIELD_NUMBER = 8; - /** - * int64 int_value = 8; - * @return Whether the intValue field is set. - */ - @java.lang.Override - public boolean hasIntValue() { - return kindCase_ == 8; - } - /** - * int64 int_value = 8; - * @return The intValue. - */ - @java.lang.Override - public long getIntValue() { - if (kindCase_ == 8) { - return (java.lang.Long) kind_; - } - return 0L; - } - - public static final int GEO_VALUE_FIELD_NUMBER = 9; - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return Whether the geoValue field is set. - */ - @java.lang.Override - public boolean hasGeoValue() { - return kindCase_ == 9; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return The geoValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getGeoValue() { - if (kindCase_ == 9) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder() { - if (kindCase_ == 9) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - - public static final int BLOB_VALUE_FIELD_NUMBER = 10; - /** - * string blob_value = 10; - * @return Whether the blobValue field is set. - */ - public boolean hasBlobValue() { - return kindCase_ == 10; - } - /** - * string blob_value = 10; - * @return The blobValue. - */ - public java.lang.String getBlobValue() { - java.lang.Object ref = ""; - if (kindCase_ == 10) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 10) { - kind_ = s; - } - return s; - } - } - /** - * string blob_value = 10; - * @return The bytes for blobValue. - */ - public com.google.protobuf.ByteString - getBlobValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 10) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 10) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int PHONE_VALUE_FIELD_NUMBER = 11; - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return Whether the phoneValue field is set. - */ - @java.lang.Override - public boolean hasPhoneValue() { - return kindCase_ == 11; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return The phoneValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getPhoneValue() { - if (kindCase_ == 11) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder() { - if (kindCase_ == 11) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - - public static final int NULL_VALUE_FIELD_NUMBER = 12; - /** - * .google.protobuf.NullValue null_value = 12; - * @return Whether the nullValue field is set. - */ - public boolean hasNullValue() { - return kindCase_ == 12; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @return The enum numeric value on the wire for nullValue. - */ - public int getNullValueValue() { - if (kindCase_ == 12) { - return (java.lang.Integer) kind_; - } - return 0; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @return The nullValue. - */ - public com.google.protobuf.NullValue getNullValue() { - if (kindCase_ == 12) { - com.google.protobuf.NullValue result = com.google.protobuf.NullValue.forNumber( - (java.lang.Integer) kind_); - return result == null ? com.google.protobuf.NullValue.UNRECOGNIZED : result; - } - return com.google.protobuf.NullValue.NULL_VALUE; - } - - public static final int TEXT_VALUE_FIELD_NUMBER = 13; - /** - * string text_value = 13; - * @return Whether the textValue field is set. - */ - public boolean hasTextValue() { - return kindCase_ == 13; - } - /** - * string text_value = 13; - * @return The textValue. - */ - public java.lang.String getTextValue() { - java.lang.Object ref = ""; - if (kindCase_ == 13) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 13) { - kind_ = s; - } - return s; - } - } - /** - * string text_value = 13; - * @return The bytes for textValue. - */ - public com.google.protobuf.ByteString - getTextValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 13) { - ref = kind_; - } - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 13) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (kindCase_ == 1) { - output.writeDouble( - 1, (double)((java.lang.Double) kind_)); - } - if (kindCase_ == 3) { - output.writeBool( - 3, (boolean)((java.lang.Boolean) kind_)); - } - if (kindCase_ == 4) { - output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_); - } - if (kindCase_ == 5) { - output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_); - } - if (kindCase_ == 6) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 6, kind_); - } - if (kindCase_ == 7) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 7, kind_); - } - if (kindCase_ == 8) { - output.writeInt64( - 8, (long)((java.lang.Long) kind_)); - } - if (kindCase_ == 9) { - output.writeMessage(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_); - } - if (kindCase_ == 10) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 10, kind_); - } - if (kindCase_ == 11) { - output.writeMessage(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_); - } - if (kindCase_ == 12) { - output.writeEnum(12, ((java.lang.Integer) kind_)); - } - if (kindCase_ == 13) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 13, kind_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (kindCase_ == 1) { - size += com.google.protobuf.CodedOutputStream - .computeDoubleSize( - 1, (double)((java.lang.Double) kind_)); - } - if (kindCase_ == 3) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize( - 3, (boolean)((java.lang.Boolean) kind_)); - } - if (kindCase_ == 4) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_); - } - if (kindCase_ == 5) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_); - } - if (kindCase_ == 6) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, kind_); - } - if (kindCase_ == 7) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(7, kind_); - } - if (kindCase_ == 8) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size( - 8, (long)((java.lang.Long) kind_)); - } - if (kindCase_ == 9) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_); - } - if (kindCase_ == 10) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(10, kind_); - } - if (kindCase_ == 11) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_); - } - if (kindCase_ == 12) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(12, ((java.lang.Integer) kind_)); - } - if (kindCase_ == 13) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(13, kind_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value) obj; - - if (!getKindCase().equals(other.getKindCase())) return false; - switch (kindCase_) { - case 1: - if (java.lang.Double.doubleToLongBits(getNumberValue()) - != java.lang.Double.doubleToLongBits( - other.getNumberValue())) return false; - break; - case 3: - if (getBoolValue() - != other.getBoolValue()) return false; - break; - case 4: - if (!getObjectValue() - .equals(other.getObjectValue())) return false; - break; - case 5: - if (!getListValue() - .equals(other.getListValue())) return false; - break; - case 6: - if (!getDateValue() - .equals(other.getDateValue())) return false; - break; - case 7: - if (!getUuidValue() - .equals(other.getUuidValue())) return false; - break; - case 8: - if (getIntValue() - != other.getIntValue()) return false; - break; - case 9: - if (!getGeoValue() - .equals(other.getGeoValue())) return false; - break; - case 10: - if (!getBlobValue() - .equals(other.getBlobValue())) return false; - break; - case 11: - if (!getPhoneValue() - .equals(other.getPhoneValue())) return false; - break; - case 12: - if (getNullValueValue() - != other.getNullValueValue()) return false; - break; - case 13: - if (!getTextValue() - .equals(other.getTextValue())) return false; - break; - case 0: - default: - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - switch (kindCase_) { - case 1: - hash = (37 * hash) + NUMBER_VALUE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - java.lang.Double.doubleToLongBits(getNumberValue())); - break; - case 3: - hash = (37 * hash) + BOOL_VALUE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getBoolValue()); - break; - case 4: - hash = (37 * hash) + OBJECT_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getObjectValue().hashCode(); - break; - case 5: - hash = (37 * hash) + LIST_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getListValue().hashCode(); - break; - case 6: - hash = (37 * hash) + DATE_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getDateValue().hashCode(); - break; - case 7: - hash = (37 * hash) + UUID_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getUuidValue().hashCode(); - break; - case 8: - hash = (37 * hash) + INT_VALUE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getIntValue()); - break; - case 9: - hash = (37 * hash) + GEO_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getGeoValue().hashCode(); - break; - case 10: - hash = (37 * hash) + BLOB_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getBlobValue().hashCode(); - break; - case 11: - hash = (37 * hash) + PHONE_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getPhoneValue().hashCode(); - break; - case 12: - hash = (37 * hash) + NULL_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getNullValueValue(); - break; - case 13: - hash = (37 * hash) + TEXT_VALUE_FIELD_NUMBER; - hash = (53 * hash) + getTextValue().hashCode(); - break; - case 0: - default: - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.Value} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.Value) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ValueOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Value_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (objectValueBuilder_ != null) { - objectValueBuilder_.clear(); - } - if (listValueBuilder_ != null) { - listValueBuilder_.clear(); - } - if (geoValueBuilder_ != null) { - geoValueBuilder_.clear(); - } - if (phoneValueBuilder_ != null) { - phoneValueBuilder_.clear(); - } - kindCase_ = 0; - kind_ = null; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value(this); - if (bitField0_ != 0) { buildPartial0(result); } - buildPartialOneofs(result); - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value result) { - int from_bitField0_ = bitField0_; - } - - private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value result) { - result.kindCase_ = kindCase_; - result.kind_ = this.kind_; - if (kindCase_ == 4 && - objectValueBuilder_ != null) { - result.kind_ = objectValueBuilder_.build(); - } - if (kindCase_ == 5 && - listValueBuilder_ != null) { - result.kind_ = listValueBuilder_.build(); - } - if (kindCase_ == 9 && - geoValueBuilder_ != null) { - result.kind_ = geoValueBuilder_.build(); - } - if (kindCase_ == 11 && - phoneValueBuilder_ != null) { - result.kind_ = phoneValueBuilder_.build(); - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value.getDefaultInstance()) return this; - switch (other.getKindCase()) { - case NUMBER_VALUE: { - setNumberValue(other.getNumberValue()); - break; - } - case BOOL_VALUE: { - setBoolValue(other.getBoolValue()); - break; - } - case OBJECT_VALUE: { - mergeObjectValue(other.getObjectValue()); - break; - } - case LIST_VALUE: { - mergeListValue(other.getListValue()); - break; - } - case DATE_VALUE: { - kindCase_ = 6; - kind_ = other.kind_; - onChanged(); - break; - } - case UUID_VALUE: { - kindCase_ = 7; - kind_ = other.kind_; - onChanged(); - break; - } - case INT_VALUE: { - setIntValue(other.getIntValue()); - break; - } - case GEO_VALUE: { - mergeGeoValue(other.getGeoValue()); - break; - } - case BLOB_VALUE: { - kindCase_ = 10; - kind_ = other.kind_; - onChanged(); - break; - } - case PHONE_VALUE: { - mergePhoneValue(other.getPhoneValue()); - break; - } - case NULL_VALUE: { - setNullValueValue(other.getNullValueValue()); - break; - } - case TEXT_VALUE: { - kindCase_ = 13; - kind_ = other.kind_; - onChanged(); - break; - } - case KIND_NOT_SET: { - break; - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 9: { - kind_ = input.readDouble(); - kindCase_ = 1; - break; - } // case 9 - case 24: { - kind_ = input.readBool(); - kindCase_ = 3; - break; - } // case 24 - case 34: { - input.readMessage( - getObjectValueFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 4; - break; - } // case 34 - case 42: { - input.readMessage( - getListValueFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 5; - break; - } // case 42 - case 50: { - java.lang.String s = input.readStringRequireUtf8(); - kindCase_ = 6; - kind_ = s; - break; - } // case 50 - case 58: { - java.lang.String s = input.readStringRequireUtf8(); - kindCase_ = 7; - kind_ = s; - break; - } // case 58 - case 64: { - kind_ = input.readInt64(); - kindCase_ = 8; - break; - } // case 64 - case 74: { - input.readMessage( - getGeoValueFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 9; - break; - } // case 74 - case 82: { - java.lang.String s = input.readStringRequireUtf8(); - kindCase_ = 10; - kind_ = s; - break; - } // case 82 - case 90: { - input.readMessage( - getPhoneValueFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 11; - break; - } // case 90 - case 96: { - int rawValue = input.readEnum(); - kindCase_ = 12; - kind_ = rawValue; - break; - } // case 96 - case 106: { - java.lang.String s = input.readStringRequireUtf8(); - kindCase_ = 13; - kind_ = s; - break; - } // case 106 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int kindCase_ = 0; - private java.lang.Object kind_; - public KindCase - getKindCase() { - return KindCase.forNumber( - kindCase_); - } - - public Builder clearKind() { - kindCase_ = 0; - kind_ = null; - onChanged(); - return this; - } - - private int bitField0_; - - /** - * double number_value = 1; - * @return Whether the numberValue field is set. - */ - public boolean hasNumberValue() { - return kindCase_ == 1; - } - /** - * double number_value = 1; - * @return The numberValue. - */ - public double getNumberValue() { - if (kindCase_ == 1) { - return (java.lang.Double) kind_; - } - return 0D; - } - /** - * double number_value = 1; - * @param value The numberValue to set. - * @return This builder for chaining. - */ - public Builder setNumberValue(double value) { - - kindCase_ = 1; - kind_ = value; - onChanged(); - return this; - } - /** - * double number_value = 1; - * @return This builder for chaining. - */ - public Builder clearNumberValue() { - if (kindCase_ == 1) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - - /** - *
-       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-       * 
- * - * bool bool_value = 3; - * @return Whether the boolValue field is set. - */ - public boolean hasBoolValue() { - return kindCase_ == 3; - } - /** - *
-       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-       * 
- * - * bool bool_value = 3; - * @return The boolValue. - */ - public boolean getBoolValue() { - if (kindCase_ == 3) { - return (java.lang.Boolean) kind_; - } - return false; - } - /** - *
-       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-       * 
- * - * bool bool_value = 3; - * @param value The boolValue to set. - * @return This builder for chaining. - */ - public Builder setBoolValue(boolean value) { - - kindCase_ = 3; - kind_ = value; - onChanged(); - return this; - } - /** - *
-       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
-       * 
- * - * bool bool_value = 3; - * @return This builder for chaining. - */ - public Builder clearBoolValue() { - if (kindCase_ == 3) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> objectValueBuilder_; - /** - * .weaviate.v1.Properties object_value = 4; - * @return Whether the objectValue field is set. - */ - @java.lang.Override - public boolean hasObjectValue() { - return kindCase_ == 4; - } - /** - * .weaviate.v1.Properties object_value = 4; - * @return The objectValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getObjectValue() { - if (objectValueBuilder_ == null) { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } else { - if (kindCase_ == 4) { - return objectValueBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - public Builder setObjectValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (objectValueBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - objectValueBuilder_.setMessage(value); - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - public Builder setObjectValue( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder builderForValue) { - if (objectValueBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - objectValueBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - public Builder mergeObjectValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (objectValueBuilder_ == null) { - if (kindCase_ == 4 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 4) { - objectValueBuilder_.mergeFrom(value); - } else { - objectValueBuilder_.setMessage(value); - } - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - public Builder clearObjectValue() { - if (objectValueBuilder_ == null) { - if (kindCase_ == 4) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 4) { - kindCase_ = 0; - kind_ = null; - } - objectValueBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder getObjectValueBuilder() { - return getObjectValueFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder() { - if ((kindCase_ == 4) && (objectValueBuilder_ != null)) { - return objectValueBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - } - /** - * .weaviate.v1.Properties object_value = 4; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> - getObjectValueFieldBuilder() { - if (objectValueBuilder_ == null) { - if (!(kindCase_ == 4)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance(); - } - objectValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 4; - onChanged(); - return objectValueBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder> listValueBuilder_; - /** - * .weaviate.v1.ListValue list_value = 5; - * @return Whether the listValue field is set. - */ - @java.lang.Override - public boolean hasListValue() { - return kindCase_ == 5; - } - /** - * .weaviate.v1.ListValue list_value = 5; - * @return The listValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getListValue() { - if (listValueBuilder_ == null) { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } else { - if (kindCase_ == 5) { - return listValueBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - public Builder setListValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue value) { - if (listValueBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - listValueBuilder_.setMessage(value); - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - public Builder setListValue( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder builderForValue) { - if (listValueBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - listValueBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - public Builder mergeListValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue value) { - if (listValueBuilder_ == null) { - if (kindCase_ == 5 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 5) { - listValueBuilder_.mergeFrom(value); - } else { - listValueBuilder_.setMessage(value); - } - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - public Builder clearListValue() { - if (listValueBuilder_ == null) { - if (kindCase_ == 5) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 5) { - kindCase_ = 0; - kind_ = null; - } - listValueBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder getListValueBuilder() { - return getListValueFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder() { - if ((kindCase_ == 5) && (listValueBuilder_ != null)) { - return listValueBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - } - /** - * .weaviate.v1.ListValue list_value = 5; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder> - getListValueFieldBuilder() { - if (listValueBuilder_ == null) { - if (!(kindCase_ == 5)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - listValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 5; - onChanged(); - return listValueBuilder_; - } - - /** - * string date_value = 6; - * @return Whether the dateValue field is set. - */ - @java.lang.Override - public boolean hasDateValue() { - return kindCase_ == 6; - } - /** - * string date_value = 6; - * @return The dateValue. - */ - @java.lang.Override - public java.lang.String getDateValue() { - java.lang.Object ref = ""; - if (kindCase_ == 6) { - ref = kind_; - } - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 6) { - kind_ = s; - } - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string date_value = 6; - * @return The bytes for dateValue. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getDateValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 6) { - ref = kind_; - } - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 6) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string date_value = 6; - * @param value The dateValue to set. - * @return This builder for chaining. - */ - public Builder setDateValue( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - kindCase_ = 6; - kind_ = value; - onChanged(); - return this; - } - /** - * string date_value = 6; - * @return This builder for chaining. - */ - public Builder clearDateValue() { - if (kindCase_ == 6) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - /** - * string date_value = 6; - * @param value The bytes for dateValue to set. - * @return This builder for chaining. - */ - public Builder setDateValueBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - kindCase_ = 6; - kind_ = value; - onChanged(); - return this; - } - - /** - * string uuid_value = 7; - * @return Whether the uuidValue field is set. - */ - @java.lang.Override - public boolean hasUuidValue() { - return kindCase_ == 7; - } - /** - * string uuid_value = 7; - * @return The uuidValue. - */ - @java.lang.Override - public java.lang.String getUuidValue() { - java.lang.Object ref = ""; - if (kindCase_ == 7) { - ref = kind_; - } - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 7) { - kind_ = s; - } - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string uuid_value = 7; - * @return The bytes for uuidValue. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getUuidValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 7) { - ref = kind_; - } - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 7) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string uuid_value = 7; - * @param value The uuidValue to set. - * @return This builder for chaining. - */ - public Builder setUuidValue( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - kindCase_ = 7; - kind_ = value; - onChanged(); - return this; - } - /** - * string uuid_value = 7; - * @return This builder for chaining. - */ - public Builder clearUuidValue() { - if (kindCase_ == 7) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - /** - * string uuid_value = 7; - * @param value The bytes for uuidValue to set. - * @return This builder for chaining. - */ - public Builder setUuidValueBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - kindCase_ = 7; - kind_ = value; - onChanged(); - return this; - } - - /** - * int64 int_value = 8; - * @return Whether the intValue field is set. - */ - public boolean hasIntValue() { - return kindCase_ == 8; - } - /** - * int64 int_value = 8; - * @return The intValue. - */ - public long getIntValue() { - if (kindCase_ == 8) { - return (java.lang.Long) kind_; - } - return 0L; - } - /** - * int64 int_value = 8; - * @param value The intValue to set. - * @return This builder for chaining. - */ - public Builder setIntValue(long value) { - - kindCase_ = 8; - kind_ = value; - onChanged(); - return this; - } - /** - * int64 int_value = 8; - * @return This builder for chaining. - */ - public Builder clearIntValue() { - if (kindCase_ == 8) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder> geoValueBuilder_; - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return Whether the geoValue field is set. - */ - @java.lang.Override - public boolean hasGeoValue() { - return kindCase_ == 9; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - * @return The geoValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getGeoValue() { - if (geoValueBuilder_ == null) { - if (kindCase_ == 9) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } else { - if (kindCase_ == 9) { - return geoValueBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - public Builder setGeoValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate value) { - if (geoValueBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - geoValueBuilder_.setMessage(value); - } - kindCase_ = 9; - return this; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - public Builder setGeoValue( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder builderForValue) { - if (geoValueBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - geoValueBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 9; - return this; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - public Builder mergeGeoValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate value) { - if (geoValueBuilder_ == null) { - if (kindCase_ == 9 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 9) { - geoValueBuilder_.mergeFrom(value); - } else { - geoValueBuilder_.setMessage(value); - } - } - kindCase_ = 9; - return this; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - public Builder clearGeoValue() { - if (geoValueBuilder_ == null) { - if (kindCase_ == 9) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 9) { - kindCase_ = 0; - kind_ = null; - } - geoValueBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder getGeoValueBuilder() { - return getGeoValueFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder() { - if ((kindCase_ == 9) && (geoValueBuilder_ != null)) { - return geoValueBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 9) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - } - /** - * .weaviate.v1.GeoCoordinate geo_value = 9; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder> - getGeoValueFieldBuilder() { - if (geoValueBuilder_ == null) { - if (!(kindCase_ == 9)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - geoValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 9; - onChanged(); - return geoValueBuilder_; - } - - /** - * string blob_value = 10; - * @return Whether the blobValue field is set. - */ - @java.lang.Override - public boolean hasBlobValue() { - return kindCase_ == 10; - } - /** - * string blob_value = 10; - * @return The blobValue. - */ - @java.lang.Override - public java.lang.String getBlobValue() { - java.lang.Object ref = ""; - if (kindCase_ == 10) { - ref = kind_; - } - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 10) { - kind_ = s; - } - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string blob_value = 10; - * @return The bytes for blobValue. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getBlobValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 10) { - ref = kind_; - } - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 10) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string blob_value = 10; - * @param value The blobValue to set. - * @return This builder for chaining. - */ - public Builder setBlobValue( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - kindCase_ = 10; - kind_ = value; - onChanged(); - return this; - } - /** - * string blob_value = 10; - * @return This builder for chaining. - */ - public Builder clearBlobValue() { - if (kindCase_ == 10) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - /** - * string blob_value = 10; - * @param value The bytes for blobValue to set. - * @return This builder for chaining. - */ - public Builder setBlobValueBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - kindCase_ = 10; - kind_ = value; - onChanged(); - return this; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder> phoneValueBuilder_; - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return Whether the phoneValue field is set. - */ - @java.lang.Override - public boolean hasPhoneValue() { - return kindCase_ == 11; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - * @return The phoneValue. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getPhoneValue() { - if (phoneValueBuilder_ == null) { - if (kindCase_ == 11) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } else { - if (kindCase_ == 11) { - return phoneValueBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - public Builder setPhoneValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber value) { - if (phoneValueBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - phoneValueBuilder_.setMessage(value); - } - kindCase_ = 11; - return this; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - public Builder setPhoneValue( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder builderForValue) { - if (phoneValueBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - phoneValueBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 11; - return this; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - public Builder mergePhoneValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber value) { - if (phoneValueBuilder_ == null) { - if (kindCase_ == 11 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 11) { - phoneValueBuilder_.mergeFrom(value); - } else { - phoneValueBuilder_.setMessage(value); - } - } - kindCase_ = 11; - return this; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - public Builder clearPhoneValue() { - if (phoneValueBuilder_ == null) { - if (kindCase_ == 11) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 11) { - kindCase_ = 0; - kind_ = null; - } - phoneValueBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder getPhoneValueBuilder() { - return getPhoneValueFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder() { - if ((kindCase_ == 11) && (phoneValueBuilder_ != null)) { - return phoneValueBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 11) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - } - /** - * .weaviate.v1.PhoneNumber phone_value = 11; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder> - getPhoneValueFieldBuilder() { - if (phoneValueBuilder_ == null) { - if (!(kindCase_ == 11)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - phoneValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 11; - onChanged(); - return phoneValueBuilder_; - } - - /** - * .google.protobuf.NullValue null_value = 12; - * @return Whether the nullValue field is set. - */ - @java.lang.Override - public boolean hasNullValue() { - return kindCase_ == 12; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @return The enum numeric value on the wire for nullValue. - */ - @java.lang.Override - public int getNullValueValue() { - if (kindCase_ == 12) { - return ((java.lang.Integer) kind_).intValue(); - } - return 0; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @param value The enum numeric value on the wire for nullValue to set. - * @return This builder for chaining. - */ - public Builder setNullValueValue(int value) { - kindCase_ = 12; - kind_ = value; - onChanged(); - return this; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @return The nullValue. - */ - @java.lang.Override - public com.google.protobuf.NullValue getNullValue() { - if (kindCase_ == 12) { - com.google.protobuf.NullValue result = com.google.protobuf.NullValue.forNumber( - (java.lang.Integer) kind_); - return result == null ? com.google.protobuf.NullValue.UNRECOGNIZED : result; - } - return com.google.protobuf.NullValue.NULL_VALUE; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @param value The nullValue to set. - * @return This builder for chaining. - */ - public Builder setNullValue(com.google.protobuf.NullValue value) { - if (value == null) { - throw new NullPointerException(); - } - kindCase_ = 12; - kind_ = value.getNumber(); - onChanged(); - return this; - } - /** - * .google.protobuf.NullValue null_value = 12; - * @return This builder for chaining. - */ - public Builder clearNullValue() { - if (kindCase_ == 12) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - - /** - * string text_value = 13; - * @return Whether the textValue field is set. - */ - @java.lang.Override - public boolean hasTextValue() { - return kindCase_ == 13; - } - /** - * string text_value = 13; - * @return The textValue. - */ - @java.lang.Override - public java.lang.String getTextValue() { - java.lang.Object ref = ""; - if (kindCase_ == 13) { - ref = kind_; - } - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - if (kindCase_ == 13) { - kind_ = s; - } - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string text_value = 13; - * @return The bytes for textValue. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTextValueBytes() { - java.lang.Object ref = ""; - if (kindCase_ == 13) { - ref = kind_; - } - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - if (kindCase_ == 13) { - kind_ = b; - } - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string text_value = 13; - * @param value The textValue to set. - * @return This builder for chaining. - */ - public Builder setTextValue( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - kindCase_ = 13; - kind_ = value; - onChanged(); - return this; - } - /** - * string text_value = 13; - * @return This builder for chaining. - */ - public Builder clearTextValue() { - if (kindCase_ == 13) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - return this; - } - /** - * string text_value = 13; - * @param value The bytes for textValue to set. - * @return This builder for chaining. - */ - public Builder setTextValueBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - kindCase_ = 13; - kind_ = value; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.Value) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.Value) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Value parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ListValueOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ListValue) - com.google.protobuf.MessageOrBuilder { - - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return Whether the numberValues field is set. - */ - boolean hasNumberValues(); - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return The numberValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getNumberValues(); - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder(); - - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return Whether the boolValues field is set. - */ - boolean hasBoolValues(); - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return The boolValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getBoolValues(); - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder(); - - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return Whether the objectValues field is set. - */ - boolean hasObjectValues(); - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return The objectValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getObjectValues(); - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder(); - - /** - * .weaviate.v1.DateValues date_values = 5; - * @return Whether the dateValues field is set. - */ - boolean hasDateValues(); - /** - * .weaviate.v1.DateValues date_values = 5; - * @return The dateValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDateValues(); - /** - * .weaviate.v1.DateValues date_values = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder(); - - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return Whether the uuidValues field is set. - */ - boolean hasUuidValues(); - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return The uuidValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getUuidValues(); - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder(); - - /** - * .weaviate.v1.IntValues int_values = 7; - * @return Whether the intValues field is set. - */ - boolean hasIntValues(); - /** - * .weaviate.v1.IntValues int_values = 7; - * @return The intValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getIntValues(); - /** - * .weaviate.v1.IntValues int_values = 7; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder(); - - /** - * .weaviate.v1.TextValues text_values = 8; - * @return Whether the textValues field is set. - */ - boolean hasTextValues(); - /** - * .weaviate.v1.TextValues text_values = 8; - * @return The textValues. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getTextValues(); - /** - * .weaviate.v1.TextValues text_values = 8; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder(); - - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.KindCase getKindCase(); - } - /** - * Protobuf type {@code weaviate.v1.ListValue} - */ - public static final class ListValue extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ListValue) - ListValueOrBuilder { - private static final long serialVersionUID = 0L; - // Use ListValue.newBuilder() to construct. - private ListValue(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ListValue() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ListValue(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder.class); - } - - private int kindCase_ = 0; - @SuppressWarnings("serial") - private java.lang.Object kind_; - public enum KindCase - implements com.google.protobuf.Internal.EnumLite, - com.google.protobuf.AbstractMessage.InternalOneOfEnum { - NUMBER_VALUES(2), - BOOL_VALUES(3), - OBJECT_VALUES(4), - DATE_VALUES(5), - UUID_VALUES(6), - INT_VALUES(7), - TEXT_VALUES(8), - KIND_NOT_SET(0); - private final int value; - private KindCase(int value) { - this.value = value; - } - /** - * @param value The number of the enum to look for. - * @return The enum associated with the given number. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static KindCase valueOf(int value) { - return forNumber(value); - } - - public static KindCase forNumber(int value) { - switch (value) { - case 2: return NUMBER_VALUES; - case 3: return BOOL_VALUES; - case 4: return OBJECT_VALUES; - case 5: return DATE_VALUES; - case 6: return UUID_VALUES; - case 7: return INT_VALUES; - case 8: return TEXT_VALUES; - case 0: return KIND_NOT_SET; - default: return null; - } - } - public int getNumber() { - return this.value; - } - }; - - public KindCase - getKindCase() { - return KindCase.forNumber( - kindCase_); - } - - public static final int NUMBER_VALUES_FIELD_NUMBER = 2; - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return Whether the numberValues field is set. - */ - @java.lang.Override - public boolean hasNumberValues() { - return kindCase_ == 2; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return The numberValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getNumberValues() { - if (kindCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder() { - if (kindCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - - public static final int BOOL_VALUES_FIELD_NUMBER = 3; - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return Whether the boolValues field is set. - */ - @java.lang.Override - public boolean hasBoolValues() { - return kindCase_ == 3; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return The boolValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getBoolValues() { - if (kindCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder() { - if (kindCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - - public static final int OBJECT_VALUES_FIELD_NUMBER = 4; - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return Whether the objectValues field is set. - */ - @java.lang.Override - public boolean hasObjectValues() { - return kindCase_ == 4; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return The objectValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getObjectValues() { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder() { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - - public static final int DATE_VALUES_FIELD_NUMBER = 5; - /** - * .weaviate.v1.DateValues date_values = 5; - * @return Whether the dateValues field is set. - */ - @java.lang.Override - public boolean hasDateValues() { - return kindCase_ == 5; - } - /** - * .weaviate.v1.DateValues date_values = 5; - * @return The dateValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDateValues() { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder() { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - - public static final int UUID_VALUES_FIELD_NUMBER = 6; - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return Whether the uuidValues field is set. - */ - @java.lang.Override - public boolean hasUuidValues() { - return kindCase_ == 6; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return The uuidValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getUuidValues() { - if (kindCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder() { - if (kindCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - - public static final int INT_VALUES_FIELD_NUMBER = 7; - /** - * .weaviate.v1.IntValues int_values = 7; - * @return Whether the intValues field is set. - */ - @java.lang.Override - public boolean hasIntValues() { - return kindCase_ == 7; - } - /** - * .weaviate.v1.IntValues int_values = 7; - * @return The intValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getIntValues() { - if (kindCase_ == 7) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder() { - if (kindCase_ == 7) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - - public static final int TEXT_VALUES_FIELD_NUMBER = 8; - /** - * .weaviate.v1.TextValues text_values = 8; - * @return Whether the textValues field is set. - */ - @java.lang.Override - public boolean hasTextValues() { - return kindCase_ == 8; - } - /** - * .weaviate.v1.TextValues text_values = 8; - * @return The textValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getTextValues() { - if (kindCase_ == 8) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder() { - if (kindCase_ == 8) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (kindCase_ == 2) { - output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_); - } - if (kindCase_ == 3) { - output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_); - } - if (kindCase_ == 4) { - output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_); - } - if (kindCase_ == 5) { - output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_); - } - if (kindCase_ == 6) { - output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_); - } - if (kindCase_ == 7) { - output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_); - } - if (kindCase_ == 8) { - output.writeMessage(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (kindCase_ == 2) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_); - } - if (kindCase_ == 3) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_); - } - if (kindCase_ == 4) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_); - } - if (kindCase_ == 5) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_); - } - if (kindCase_ == 6) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_); - } - if (kindCase_ == 7) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_); - } - if (kindCase_ == 8) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) obj; - - if (!getKindCase().equals(other.getKindCase())) return false; - switch (kindCase_) { - case 2: - if (!getNumberValues() - .equals(other.getNumberValues())) return false; - break; - case 3: - if (!getBoolValues() - .equals(other.getBoolValues())) return false; - break; - case 4: - if (!getObjectValues() - .equals(other.getObjectValues())) return false; - break; - case 5: - if (!getDateValues() - .equals(other.getDateValues())) return false; - break; - case 6: - if (!getUuidValues() - .equals(other.getUuidValues())) return false; - break; - case 7: - if (!getIntValues() - .equals(other.getIntValues())) return false; - break; - case 8: - if (!getTextValues() - .equals(other.getTextValues())) return false; - break; - case 0: - default: - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - switch (kindCase_) { - case 2: - hash = (37 * hash) + NUMBER_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getNumberValues().hashCode(); - break; - case 3: - hash = (37 * hash) + BOOL_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getBoolValues().hashCode(); - break; - case 4: - hash = (37 * hash) + OBJECT_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getObjectValues().hashCode(); - break; - case 5: - hash = (37 * hash) + DATE_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getDateValues().hashCode(); - break; - case 6: - hash = (37 * hash) + UUID_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getUuidValues().hashCode(); - break; - case 7: - hash = (37 * hash) + INT_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getIntValues().hashCode(); - break; - case 8: - hash = (37 * hash) + TEXT_VALUES_FIELD_NUMBER; - hash = (53 * hash) + getTextValues().hashCode(); - break; - case 0: - default: - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ListValue} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ListValue) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValueOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (numberValuesBuilder_ != null) { - numberValuesBuilder_.clear(); - } - if (boolValuesBuilder_ != null) { - boolValuesBuilder_.clear(); - } - if (objectValuesBuilder_ != null) { - objectValuesBuilder_.clear(); - } - if (dateValuesBuilder_ != null) { - dateValuesBuilder_.clear(); - } - if (uuidValuesBuilder_ != null) { - uuidValuesBuilder_.clear(); - } - if (intValuesBuilder_ != null) { - intValuesBuilder_.clear(); - } - if (textValuesBuilder_ != null) { - textValuesBuilder_.clear(); - } - kindCase_ = 0; - kind_ = null; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue(this); - if (bitField0_ != 0) { buildPartial0(result); } - buildPartialOneofs(result); - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue result) { - int from_bitField0_ = bitField0_; - } - - private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue result) { - result.kindCase_ = kindCase_; - result.kind_ = this.kind_; - if (kindCase_ == 2 && - numberValuesBuilder_ != null) { - result.kind_ = numberValuesBuilder_.build(); - } - if (kindCase_ == 3 && - boolValuesBuilder_ != null) { - result.kind_ = boolValuesBuilder_.build(); - } - if (kindCase_ == 4 && - objectValuesBuilder_ != null) { - result.kind_ = objectValuesBuilder_.build(); - } - if (kindCase_ == 5 && - dateValuesBuilder_ != null) { - result.kind_ = dateValuesBuilder_.build(); - } - if (kindCase_ == 6 && - uuidValuesBuilder_ != null) { - result.kind_ = uuidValuesBuilder_.build(); - } - if (kindCase_ == 7 && - intValuesBuilder_ != null) { - result.kind_ = intValuesBuilder_.build(); - } - if (kindCase_ == 8 && - textValuesBuilder_ != null) { - result.kind_ = textValuesBuilder_.build(); - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue.getDefaultInstance()) return this; - switch (other.getKindCase()) { - case NUMBER_VALUES: { - mergeNumberValues(other.getNumberValues()); - break; - } - case BOOL_VALUES: { - mergeBoolValues(other.getBoolValues()); - break; - } - case OBJECT_VALUES: { - mergeObjectValues(other.getObjectValues()); - break; - } - case DATE_VALUES: { - mergeDateValues(other.getDateValues()); - break; - } - case UUID_VALUES: { - mergeUuidValues(other.getUuidValues()); - break; - } - case INT_VALUES: { - mergeIntValues(other.getIntValues()); - break; - } - case TEXT_VALUES: { - mergeTextValues(other.getTextValues()); - break; - } - case KIND_NOT_SET: { - break; - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 18: { - input.readMessage( - getNumberValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 2; - break; - } // case 18 - case 26: { - input.readMessage( - getBoolValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 3; - break; - } // case 26 - case 34: { - input.readMessage( - getObjectValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 4; - break; - } // case 34 - case 42: { - input.readMessage( - getDateValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 5; - break; - } // case 42 - case 50: { - input.readMessage( - getUuidValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 6; - break; - } // case 50 - case 58: { - input.readMessage( - getIntValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 7; - break; - } // case 58 - case 66: { - input.readMessage( - getTextValuesFieldBuilder().getBuilder(), - extensionRegistry); - kindCase_ = 8; - break; - } // case 66 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int kindCase_ = 0; - private java.lang.Object kind_; - public KindCase - getKindCase() { - return KindCase.forNumber( - kindCase_); - } - - public Builder clearKind() { - kindCase_ = 0; - kind_ = null; - onChanged(); - return this; - } - - private int bitField0_; - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder> numberValuesBuilder_; - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return Whether the numberValues field is set. - */ - @java.lang.Override - public boolean hasNumberValues() { - return kindCase_ == 2; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - * @return The numberValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getNumberValues() { - if (numberValuesBuilder_ == null) { - if (kindCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } else { - if (kindCase_ == 2) { - return numberValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - public Builder setNumberValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues value) { - if (numberValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - numberValuesBuilder_.setMessage(value); - } - kindCase_ = 2; - return this; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - public Builder setNumberValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder builderForValue) { - if (numberValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - numberValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 2; - return this; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - public Builder mergeNumberValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues value) { - if (numberValuesBuilder_ == null) { - if (kindCase_ == 2 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 2) { - numberValuesBuilder_.mergeFrom(value); - } else { - numberValuesBuilder_.setMessage(value); - } - } - kindCase_ = 2; - return this; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - public Builder clearNumberValues() { - if (numberValuesBuilder_ == null) { - if (kindCase_ == 2) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 2) { - kindCase_ = 0; - kind_ = null; - } - numberValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder getNumberValuesBuilder() { - return getNumberValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder() { - if ((kindCase_ == 2) && (numberValuesBuilder_ != null)) { - return numberValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.NumberValues number_values = 2; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder> - getNumberValuesFieldBuilder() { - if (numberValuesBuilder_ == null) { - if (!(kindCase_ == 2)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - numberValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 2; - onChanged(); - return numberValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder> boolValuesBuilder_; - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return Whether the boolValues field is set. - */ - @java.lang.Override - public boolean hasBoolValues() { - return kindCase_ == 3; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - * @return The boolValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getBoolValues() { - if (boolValuesBuilder_ == null) { - if (kindCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } else { - if (kindCase_ == 3) { - return boolValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - public Builder setBoolValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues value) { - if (boolValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - boolValuesBuilder_.setMessage(value); - } - kindCase_ = 3; - return this; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - public Builder setBoolValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder builderForValue) { - if (boolValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - boolValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 3; - return this; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - public Builder mergeBoolValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues value) { - if (boolValuesBuilder_ == null) { - if (kindCase_ == 3 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 3) { - boolValuesBuilder_.mergeFrom(value); - } else { - boolValuesBuilder_.setMessage(value); - } - } - kindCase_ = 3; - return this; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - public Builder clearBoolValues() { - if (boolValuesBuilder_ == null) { - if (kindCase_ == 3) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 3) { - kindCase_ = 0; - kind_ = null; - } - boolValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder getBoolValuesBuilder() { - return getBoolValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder() { - if ((kindCase_ == 3) && (boolValuesBuilder_ != null)) { - return boolValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 3) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.BoolValues bool_values = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder> - getBoolValuesFieldBuilder() { - if (boolValuesBuilder_ == null) { - if (!(kindCase_ == 3)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - boolValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 3; - onChanged(); - return boolValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder> objectValuesBuilder_; - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return Whether the objectValues field is set. - */ - @java.lang.Override - public boolean hasObjectValues() { - return kindCase_ == 4; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - * @return The objectValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getObjectValues() { - if (objectValuesBuilder_ == null) { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } else { - if (kindCase_ == 4) { - return objectValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - public Builder setObjectValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues value) { - if (objectValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - objectValuesBuilder_.setMessage(value); - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - public Builder setObjectValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder builderForValue) { - if (objectValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - objectValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - public Builder mergeObjectValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues value) { - if (objectValuesBuilder_ == null) { - if (kindCase_ == 4 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 4) { - objectValuesBuilder_.mergeFrom(value); - } else { - objectValuesBuilder_.setMessage(value); - } - } - kindCase_ = 4; - return this; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - public Builder clearObjectValues() { - if (objectValuesBuilder_ == null) { - if (kindCase_ == 4) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 4) { - kindCase_ = 0; - kind_ = null; - } - objectValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder getObjectValuesBuilder() { - return getObjectValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder() { - if ((kindCase_ == 4) && (objectValuesBuilder_ != null)) { - return objectValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 4) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.ObjectValues object_values = 4; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder> - getObjectValuesFieldBuilder() { - if (objectValuesBuilder_ == null) { - if (!(kindCase_ == 4)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - objectValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 4; - onChanged(); - return objectValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder> dateValuesBuilder_; - /** - * .weaviate.v1.DateValues date_values = 5; - * @return Whether the dateValues field is set. - */ - @java.lang.Override - public boolean hasDateValues() { - return kindCase_ == 5; - } - /** - * .weaviate.v1.DateValues date_values = 5; - * @return The dateValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDateValues() { - if (dateValuesBuilder_ == null) { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } else { - if (kindCase_ == 5) { - return dateValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - public Builder setDateValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues value) { - if (dateValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - dateValuesBuilder_.setMessage(value); - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - public Builder setDateValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder builderForValue) { - if (dateValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - dateValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - public Builder mergeDateValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues value) { - if (dateValuesBuilder_ == null) { - if (kindCase_ == 5 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 5) { - dateValuesBuilder_.mergeFrom(value); - } else { - dateValuesBuilder_.setMessage(value); - } - } - kindCase_ = 5; - return this; - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - public Builder clearDateValues() { - if (dateValuesBuilder_ == null) { - if (kindCase_ == 5) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 5) { - kindCase_ = 0; - kind_ = null; - } - dateValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder getDateValuesBuilder() { - return getDateValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder() { - if ((kindCase_ == 5) && (dateValuesBuilder_ != null)) { - return dateValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 5) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.DateValues date_values = 5; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder> - getDateValuesFieldBuilder() { - if (dateValuesBuilder_ == null) { - if (!(kindCase_ == 5)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - dateValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 5; - onChanged(); - return dateValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder> uuidValuesBuilder_; - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return Whether the uuidValues field is set. - */ - @java.lang.Override - public boolean hasUuidValues() { - return kindCase_ == 6; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - * @return The uuidValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getUuidValues() { - if (uuidValuesBuilder_ == null) { - if (kindCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } else { - if (kindCase_ == 6) { - return uuidValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - public Builder setUuidValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues value) { - if (uuidValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - uuidValuesBuilder_.setMessage(value); - } - kindCase_ = 6; - return this; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - public Builder setUuidValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder builderForValue) { - if (uuidValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - uuidValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 6; - return this; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - public Builder mergeUuidValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues value) { - if (uuidValuesBuilder_ == null) { - if (kindCase_ == 6 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 6) { - uuidValuesBuilder_.mergeFrom(value); - } else { - uuidValuesBuilder_.setMessage(value); - } - } - kindCase_ = 6; - return this; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - public Builder clearUuidValues() { - if (uuidValuesBuilder_ == null) { - if (kindCase_ == 6) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 6) { - kindCase_ = 0; - kind_ = null; - } - uuidValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder getUuidValuesBuilder() { - return getUuidValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder() { - if ((kindCase_ == 6) && (uuidValuesBuilder_ != null)) { - return uuidValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 6) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.UuidValues uuid_values = 6; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder> - getUuidValuesFieldBuilder() { - if (uuidValuesBuilder_ == null) { - if (!(kindCase_ == 6)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - uuidValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 6; - onChanged(); - return uuidValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder> intValuesBuilder_; - /** - * .weaviate.v1.IntValues int_values = 7; - * @return Whether the intValues field is set. - */ - @java.lang.Override - public boolean hasIntValues() { - return kindCase_ == 7; - } - /** - * .weaviate.v1.IntValues int_values = 7; - * @return The intValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getIntValues() { - if (intValuesBuilder_ == null) { - if (kindCase_ == 7) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } else { - if (kindCase_ == 7) { - return intValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - public Builder setIntValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues value) { - if (intValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - intValuesBuilder_.setMessage(value); - } - kindCase_ = 7; - return this; - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - public Builder setIntValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder builderForValue) { - if (intValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - intValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 7; - return this; - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - public Builder mergeIntValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues value) { - if (intValuesBuilder_ == null) { - if (kindCase_ == 7 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 7) { - intValuesBuilder_.mergeFrom(value); - } else { - intValuesBuilder_.setMessage(value); - } - } - kindCase_ = 7; - return this; - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - public Builder clearIntValues() { - if (intValuesBuilder_ == null) { - if (kindCase_ == 7) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 7) { - kindCase_ = 0; - kind_ = null; - } - intValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder getIntValuesBuilder() { - return getIntValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder() { - if ((kindCase_ == 7) && (intValuesBuilder_ != null)) { - return intValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 7) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.IntValues int_values = 7; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder> - getIntValuesFieldBuilder() { - if (intValuesBuilder_ == null) { - if (!(kindCase_ == 7)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - intValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 7; - onChanged(); - return intValuesBuilder_; - } - - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder> textValuesBuilder_; - /** - * .weaviate.v1.TextValues text_values = 8; - * @return Whether the textValues field is set. - */ - @java.lang.Override - public boolean hasTextValues() { - return kindCase_ == 8; - } - /** - * .weaviate.v1.TextValues text_values = 8; - * @return The textValues. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getTextValues() { - if (textValuesBuilder_ == null) { - if (kindCase_ == 8) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } else { - if (kindCase_ == 8) { - return textValuesBuilder_.getMessage(); - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - public Builder setTextValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues value) { - if (textValuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - kind_ = value; - onChanged(); - } else { - textValuesBuilder_.setMessage(value); - } - kindCase_ = 8; - return this; - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - public Builder setTextValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder builderForValue) { - if (textValuesBuilder_ == null) { - kind_ = builderForValue.build(); - onChanged(); - } else { - textValuesBuilder_.setMessage(builderForValue.build()); - } - kindCase_ = 8; - return this; - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - public Builder mergeTextValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues value) { - if (textValuesBuilder_ == null) { - if (kindCase_ == 8 && - kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance()) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_) - .mergeFrom(value).buildPartial(); - } else { - kind_ = value; - } - onChanged(); - } else { - if (kindCase_ == 8) { - textValuesBuilder_.mergeFrom(value); - } else { - textValuesBuilder_.setMessage(value); - } - } - kindCase_ = 8; - return this; - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - public Builder clearTextValues() { - if (textValuesBuilder_ == null) { - if (kindCase_ == 8) { - kindCase_ = 0; - kind_ = null; - onChanged(); - } - } else { - if (kindCase_ == 8) { - kindCase_ = 0; - kind_ = null; - } - textValuesBuilder_.clear(); - } - return this; - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder getTextValuesBuilder() { - return getTextValuesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder() { - if ((kindCase_ == 8) && (textValuesBuilder_ != null)) { - return textValuesBuilder_.getMessageOrBuilder(); - } else { - if (kindCase_ == 8) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_; - } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - } - /** - * .weaviate.v1.TextValues text_values = 8; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder> - getTextValuesFieldBuilder() { - if (textValuesBuilder_ == null) { - if (!(kindCase_ == 8)) { - kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - textValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) kind_, - getParentForChildren(), - isClean()); - kind_ = null; - } - kindCase_ = 8; - onChanged(); - return textValuesBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ListValue) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ListValue) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ListValue parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ListValue getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface NumberValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.NumberValues) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     **
-     * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
-     * The byte array is stored in little-endian order using uint64 encoding.
-     * 
- * - * bytes values = 1; - * @return The values. - */ - com.google.protobuf.ByteString getValues(); - } - /** - * Protobuf type {@code weaviate.v1.NumberValues} - */ - public static final class NumberValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.NumberValues) - NumberValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use NumberValues.newBuilder() to construct. - private NumberValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private NumberValues() { - values_ = com.google.protobuf.ByteString.EMPTY; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new NumberValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-     **
-     * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
-     * The byte array is stored in little-endian order using uint64 encoding.
-     * 
- * - * bytes values = 1; - * @return The values. - */ - @java.lang.Override - public com.google.protobuf.ByteString getValues() { - return values_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!values_.isEmpty()) { - output.writeBytes(1, values_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!values_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(1, values_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) obj; - - if (!getValues() - .equals(other.getValues())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValues().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.NumberValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.NumberValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = com.google.protobuf.ByteString.EMPTY; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues.getDefaultInstance()) return this; - if (other.getValues() != com.google.protobuf.ByteString.EMPTY) { - setValues(other.getValues()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - values_ = input.readBytes(); - bitField0_ |= 0x00000001; - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @return The values. - */ - @java.lang.Override - public com.google.protobuf.ByteString getValues() { - return values_; - } - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - values_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - bitField0_ = (bitField0_ & ~0x00000001); - values_ = getDefaultInstance().getValues(); - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.NumberValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.NumberValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public NumberValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.NumberValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface TextValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.TextValues) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string values = 1; - * @return A list containing the values. - */ - java.util.List - getValuesList(); - /** - * repeated string values = 1; - * @return The count of values. - */ - int getValuesCount(); - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - java.lang.String getValues(int index); - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - com.google.protobuf.ByteString - getValuesBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.TextValues} - */ - public static final class TextValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.TextValues) - TextValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use TextValues.newBuilder() to construct. - private TextValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private TextValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new TextValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < values_.size(); i++) { - dataSize += computeStringSizeNoTag(values_.getRaw(i)); - } - size += dataSize; - size += 1 * getValuesList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.TextValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.TextValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - values_.makeImmutable(); - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues.getDefaultInstance()) return this; - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ |= 0x00000001; - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureValuesIsMutable(); - values_.add(s); - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureValuesIsMutable() { - if (!values_.isModifiable()) { - values_ = new com.google.protobuf.LazyStringArrayList(values_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - values_.makeImmutable(); - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - /** - * repeated string values = 1; - * @param index The index to set the value at. - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The values to add. - * @return This builder for chaining. - */ - public Builder addValues( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param values The values to add. - * @return This builder for chaining. - */ - public Builder addAllValues( - java.lang.Iterable values) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The bytes of the values to add. - * @return This builder for chaining. - */ - public Builder addValuesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.TextValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.TextValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public TextValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.TextValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface BoolValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.BoolValues) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated bool values = 1; - * @return A list containing the values. - */ - java.util.List getValuesList(); - /** - * repeated bool values = 1; - * @return The count of values. - */ - int getValuesCount(); - /** - * repeated bool values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - boolean getValues(int index); - } - /** - * Protobuf type {@code weaviate.v1.BoolValues} - */ - public static final class BoolValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.BoolValues) - BoolValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use BoolValues.newBuilder() to construct. - private BoolValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private BoolValues() { - values_ = emptyBooleanList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new BoolValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.Internal.BooleanList values_ = - emptyBooleanList(); - /** - * repeated bool values = 1; - * @return A list containing the values. - */ - @java.lang.Override - public java.util.List - getValuesList() { - return values_; - } - /** - * repeated bool values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated bool values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public boolean getValues(int index) { - return values_.getBoolean(index); - } - private int valuesMemoizedSerializedSize = -1; - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getSerializedSize(); - if (getValuesList().size() > 0) { - output.writeUInt32NoTag(10); - output.writeUInt32NoTag(valuesMemoizedSerializedSize); - } - for (int i = 0; i < values_.size(); i++) { - output.writeBoolNoTag(values_.getBoolean(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - dataSize = 1 * getValuesList().size(); - size += dataSize; - if (!getValuesList().isEmpty()) { - size += 1; - size += com.google.protobuf.CodedOutputStream - .computeInt32SizeNoTag(dataSize); - } - valuesMemoizedSerializedSize = dataSize; - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.BoolValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.BoolValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = emptyBooleanList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - values_.makeImmutable(); - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues.getDefaultInstance()) return this; - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - values_.makeImmutable(); - bitField0_ |= 0x00000001; - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - boolean v = input.readBool(); - ensureValuesIsMutable(); - values_.addBoolean(v); - break; - } // case 8 - case 10: { - int length = input.readRawVarint32(); - int limit = input.pushLimit(length); - int alloc = length > 4096 ? 4096 : length; - ensureValuesIsMutable(alloc / 1); - while (input.getBytesUntilLimit() > 0) { - values_.addBoolean(input.readBool()); - } - input.popLimit(limit); - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.Internal.BooleanList values_ = emptyBooleanList(); - private void ensureValuesIsMutable() { - if (!values_.isModifiable()) { - values_ = makeMutableCopy(values_); - } - bitField0_ |= 0x00000001; - } - private void ensureValuesIsMutable(int capacity) { - if (!values_.isModifiable()) { - values_ = makeMutableCopy(values_, capacity); - } - bitField0_ |= 0x00000001; - } - /** - * repeated bool values = 1; - * @return A list containing the values. - */ - public java.util.List - getValuesList() { - values_.makeImmutable(); - return values_; - } - /** - * repeated bool values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated bool values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public boolean getValues(int index) { - return values_.getBoolean(index); - } - /** - * repeated bool values = 1; - * @param index The index to set the value at. - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues( - int index, boolean value) { - - ensureValuesIsMutable(); - values_.setBoolean(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated bool values = 1; - * @param value The values to add. - * @return This builder for chaining. - */ - public Builder addValues(boolean value) { - - ensureValuesIsMutable(); - values_.addBoolean(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated bool values = 1; - * @param values The values to add. - * @return This builder for chaining. - */ - public Builder addAllValues( - java.lang.Iterable values) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated bool values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - values_ = emptyBooleanList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.BoolValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.BoolValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public BoolValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.BoolValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ObjectValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ObjectValues) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.Properties values = 1; - */ - java.util.List - getValuesList(); - /** - * repeated .weaviate.v1.Properties values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getValues(int index); - /** - * repeated .weaviate.v1.Properties values = 1; - */ - int getValuesCount(); - /** - * repeated .weaviate.v1.Properties values = 1; - */ - java.util.List - getValuesOrBuilderList(); - /** - * repeated .weaviate.v1.Properties values = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.ObjectValues} - */ - public static final class ObjectValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ObjectValues) - ObjectValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use ObjectValues.newBuilder() to construct. - private ObjectValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ObjectValues() { - values_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ObjectValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List values_; - /** - * repeated .weaviate.v1.Properties values = 1; - */ - @java.lang.Override - public java.util.List getValuesList() { - return values_; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - @java.lang.Override - public java.util.List - getValuesOrBuilderList() { - return values_; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - @java.lang.Override - public int getValuesCount() { - return values_.size(); - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getValues(int index) { - return values_.get(index); - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( - int index) { - return values_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - output.writeMessage(1, values_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < values_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, values_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ObjectValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - } else { - values_ = null; - valuesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues result) { - if (valuesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - values_ = java.util.Collections.unmodifiableList(values_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.values_ = values_; - } else { - result.values_ = valuesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues result) { - int from_bitField0_ = bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues.getDefaultInstance()) return this; - if (valuesBuilder_ == null) { - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - } else { - if (!other.values_.isEmpty()) { - if (valuesBuilder_.isEmpty()) { - valuesBuilder_.dispose(); - valuesBuilder_ = null; - values_ = other.values_; - bitField0_ = (bitField0_ & ~0x00000001); - valuesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getValuesFieldBuilder() : null; - } else { - valuesBuilder_.addAllMessages(other.values_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.parser(), - extensionRegistry); - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(m); - } else { - valuesBuilder_.addMessage(m); - } - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List values_ = - java.util.Collections.emptyList(); - private void ensureValuesIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - values_ = new java.util.ArrayList(values_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> valuesBuilder_; - - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public java.util.List getValuesList() { - if (valuesBuilder_ == null) { - return java.util.Collections.unmodifiableList(values_); - } else { - return valuesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public int getValuesCount() { - if (valuesBuilder_ == null) { - return values_.size(); - } else { - return valuesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getValues(int index) { - if (valuesBuilder_ == null) { - return values_.get(index); - } else { - return valuesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.set(index, value); - onChanged(); - } else { - valuesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder setValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.set(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(value); - onChanged(); - } else { - valuesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (valuesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureValuesIsMutable(); - values_.add(index, value); - onChanged(); - } else { - valuesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder addValues( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder addValues( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder builderForValue) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.add(index, builderForValue.build()); - onChanged(); - } else { - valuesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder addAllValues( - java.lang.Iterable values) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - onChanged(); - } else { - valuesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder clearValues() { - if (valuesBuilder_ == null) { - values_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - valuesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public Builder removeValues(int index) { - if (valuesBuilder_ == null) { - ensureValuesIsMutable(); - values_.remove(index); - onChanged(); - } else { - valuesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder getValuesBuilder( - int index) { - return getValuesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( - int index) { - if (valuesBuilder_ == null) { - return values_.get(index); } else { - return valuesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public java.util.List - getValuesOrBuilderList() { - if (valuesBuilder_ != null) { - return valuesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(values_); - } - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder addValuesBuilder() { - return getValuesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder addValuesBuilder( - int index) { - return getValuesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.Properties values = 1; - */ - public java.util.List - getValuesBuilderList() { - return getValuesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> - getValuesFieldBuilder() { - if (valuesBuilder_ == null) { - valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder>( - values_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - values_ = null; - } - return valuesBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ObjectValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ObjectValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.ObjectValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface DateValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.DateValues) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string values = 1; - * @return A list containing the values. - */ - java.util.List - getValuesList(); - /** - * repeated string values = 1; - * @return The count of values. - */ - int getValuesCount(); - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - java.lang.String getValues(int index); - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - com.google.protobuf.ByteString - getValuesBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.DateValues} - */ - public static final class DateValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.DateValues) - DateValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use DateValues.newBuilder() to construct. - private DateValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private DateValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new DateValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < values_.size(); i++) { - dataSize += computeStringSizeNoTag(values_.getRaw(i)); - } - size += dataSize; - size += 1 * getValuesList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.DateValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.DateValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - values_.makeImmutable(); - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues.getDefaultInstance()) return this; - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ |= 0x00000001; - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureValuesIsMutable(); - values_.add(s); - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureValuesIsMutable() { - if (!values_.isModifiable()) { - values_ = new com.google.protobuf.LazyStringArrayList(values_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - values_.makeImmutable(); - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - /** - * repeated string values = 1; - * @param index The index to set the value at. - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The values to add. - * @return This builder for chaining. - */ - public Builder addValues( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param values The values to add. - * @return This builder for chaining. - */ - public Builder addAllValues( - java.lang.Iterable values) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The bytes of the values to add. - * @return This builder for chaining. - */ - public Builder addValuesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.DateValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.DateValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public DateValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.DateValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface UuidValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.UuidValues) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string values = 1; - * @return A list containing the values. - */ - java.util.List - getValuesList(); - /** - * repeated string values = 1; - * @return The count of values. - */ - int getValuesCount(); - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - java.lang.String getValues(int index); - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - com.google.protobuf.ByteString - getValuesBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.UuidValues} - */ - public static final class UuidValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.UuidValues) - UuidValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use UuidValues.newBuilder() to construct. - private UuidValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private UuidValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new UuidValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < values_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < values_.size(); i++) { - dataSize += computeStringSizeNoTag(values_.getRaw(i)); - } - size += dataSize; - size += 1 * getValuesList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) obj; - - if (!getValuesList() - .equals(other.getValuesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getValuesCount() > 0) { - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValuesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.UuidValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.UuidValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - values_.makeImmutable(); - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues.getDefaultInstance()) return this; - if (!other.values_.isEmpty()) { - if (values_.isEmpty()) { - values_ = other.values_; - bitField0_ |= 0x00000001; - } else { - ensureValuesIsMutable(); - values_.addAll(other.values_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureValuesIsMutable(); - values_.add(s); - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureValuesIsMutable() { - if (!values_.isModifiable()) { - values_ = new com.google.protobuf.LazyStringArrayList(values_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string values = 1; - * @return A list containing the values. - */ - public com.google.protobuf.ProtocolStringList - getValuesList() { - values_.makeImmutable(); - return values_; - } - /** - * repeated string values = 1; - * @return The count of values. - */ - public int getValuesCount() { - return values_.size(); - } - /** - * repeated string values = 1; - * @param index The index of the element to return. - * @return The values at the given index. - */ - public java.lang.String getValues(int index) { - return values_.get(index); - } - /** - * repeated string values = 1; - * @param index The index of the value to return. - * @return The bytes of the values at the given index. - */ - public com.google.protobuf.ByteString - getValuesBytes(int index) { - return values_.getByteString(index); - } - /** - * repeated string values = 1; - * @param index The index to set the value at. - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The values to add. - * @return This builder for chaining. - */ - public Builder addValues( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param values The values to add. - * @return This builder for chaining. - */ - public Builder addAllValues( - java.lang.Iterable values) { - ensureValuesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, values_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - values_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string values = 1; - * @param value The bytes of the values to add. - * @return This builder for chaining. - */ - public Builder addValuesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureValuesIsMutable(); - values_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.UuidValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.UuidValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public UuidValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.UuidValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface IntValuesOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.IntValues) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     **
-     * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
-     * The byte array is stored in little-endian order using uint64 encoding.
-     * 
- * - * bytes values = 1; - * @return The values. - */ - com.google.protobuf.ByteString getValues(); - } - /** - * Protobuf type {@code weaviate.v1.IntValues} - */ - public static final class IntValues extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.IntValues) - IntValuesOrBuilder { - private static final long serialVersionUID = 0L; - // Use IntValues.newBuilder() to construct. - private IntValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private IntValues() { - values_ = com.google.protobuf.ByteString.EMPTY; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new IntValues(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder.class); - } - - public static final int VALUES_FIELD_NUMBER = 1; - private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-     **
-     * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
-     * The byte array is stored in little-endian order using uint64 encoding.
-     * 
- * - * bytes values = 1; - * @return The values. - */ - @java.lang.Override - public com.google.protobuf.ByteString getValues() { - return values_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!values_.isEmpty()) { - output.writeBytes(1, values_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!values_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(1, values_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) obj; - - if (!getValues() - .equals(other.getValues())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + VALUES_FIELD_NUMBER; - hash = (53 * hash) + getValues().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.IntValues} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.IntValues) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValuesOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - values_ = com.google.protobuf.ByteString.EMPTY; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.values_ = values_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues.getDefaultInstance()) return this; - if (other.getValues() != com.google.protobuf.ByteString.EMPTY) { - setValues(other.getValues()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - values_ = input.readBytes(); - bitField0_ |= 0x00000001; - break; - } // case 10 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @return The values. - */ - @java.lang.Override - public com.google.protobuf.ByteString getValues() { - return values_; - } - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @param value The values to set. - * @return This builder for chaining. - */ - public Builder setValues(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - values_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       **
-       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
-       * The byte array is stored in little-endian order using uint64 encoding.
-       * 
- * - * bytes values = 1; - * @return This builder for chaining. - */ - public Builder clearValues() { - bitField0_ = (bitField0_ & ~0x00000001); - values_ = getDefaultInstance().getValues(); - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.IntValues) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.IntValues) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public IntValues parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.IntValues getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GeoCoordinateOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GeoCoordinate) - com.google.protobuf.MessageOrBuilder { - - /** - * float longitude = 1; - * @return The longitude. - */ - float getLongitude(); - - /** - * float latitude = 2; - * @return The latitude. - */ - float getLatitude(); - } - /** - * Protobuf type {@code weaviate.v1.GeoCoordinate} - */ - public static final class GeoCoordinate extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GeoCoordinate) - GeoCoordinateOrBuilder { - private static final long serialVersionUID = 0L; - // Use GeoCoordinate.newBuilder() to construct. - private GeoCoordinate(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GeoCoordinate() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GeoCoordinate(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder.class); - } - - public static final int LONGITUDE_FIELD_NUMBER = 1; - private float longitude_ = 0F; - /** - * float longitude = 1; - * @return The longitude. - */ - @java.lang.Override - public float getLongitude() { - return longitude_; - } - - public static final int LATITUDE_FIELD_NUMBER = 2; - private float latitude_ = 0F; - /** - * float latitude = 2; - * @return The latitude. - */ - @java.lang.Override - public float getLatitude() { - return latitude_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (java.lang.Float.floatToRawIntBits(longitude_) != 0) { - output.writeFloat(1, longitude_); - } - if (java.lang.Float.floatToRawIntBits(latitude_) != 0) { - output.writeFloat(2, latitude_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (java.lang.Float.floatToRawIntBits(longitude_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(1, longitude_); - } - if (java.lang.Float.floatToRawIntBits(latitude_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(2, latitude_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) obj; - - if (java.lang.Float.floatToIntBits(getLongitude()) - != java.lang.Float.floatToIntBits( - other.getLongitude())) return false; - if (java.lang.Float.floatToIntBits(getLatitude()) - != java.lang.Float.floatToIntBits( - other.getLatitude())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + LONGITUDE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getLongitude()); - hash = (37 * hash) + LATITUDE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getLatitude()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GeoCoordinate} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GeoCoordinate) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinateOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - longitude_ = 0F; - latitude_ = 0F; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.longitude_ = longitude_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.latitude_ = latitude_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance()) return this; - if (other.getLongitude() != 0F) { - setLongitude(other.getLongitude()); - } - if (other.getLatitude() != 0F) { - setLatitude(other.getLatitude()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 13: { - longitude_ = input.readFloat(); - bitField0_ |= 0x00000001; - break; - } // case 13 - case 21: { - latitude_ = input.readFloat(); - bitField0_ |= 0x00000002; - break; - } // case 21 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private float longitude_ ; - /** - * float longitude = 1; - * @return The longitude. - */ - @java.lang.Override - public float getLongitude() { - return longitude_; - } - /** - * float longitude = 1; - * @param value The longitude to set. - * @return This builder for chaining. - */ - public Builder setLongitude(float value) { - - longitude_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * float longitude = 1; - * @return This builder for chaining. - */ - public Builder clearLongitude() { - bitField0_ = (bitField0_ & ~0x00000001); - longitude_ = 0F; - onChanged(); - return this; - } - - private float latitude_ ; - /** - * float latitude = 2; - * @return The latitude. - */ - @java.lang.Override - public float getLatitude() { - return latitude_; - } - /** - * float latitude = 2; - * @param value The latitude to set. - * @return This builder for chaining. - */ - public Builder setLatitude(float value) { - - latitude_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * float latitude = 2; - * @return This builder for chaining. - */ - public Builder clearLatitude() { - bitField0_ = (bitField0_ & ~0x00000002); - latitude_ = 0F; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GeoCoordinate) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GeoCoordinate) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GeoCoordinate parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.GeoCoordinate getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface PhoneNumberOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PhoneNumber) - com.google.protobuf.MessageOrBuilder { - - /** - * uint64 country_code = 1; - * @return The countryCode. - */ - long getCountryCode(); - - /** - * string default_country = 2; - * @return The defaultCountry. - */ - java.lang.String getDefaultCountry(); - /** - * string default_country = 2; - * @return The bytes for defaultCountry. - */ - com.google.protobuf.ByteString - getDefaultCountryBytes(); - - /** - * string input = 3; - * @return The input. - */ - java.lang.String getInput(); - /** - * string input = 3; - * @return The bytes for input. - */ - com.google.protobuf.ByteString - getInputBytes(); - - /** - * string international_formatted = 4; - * @return The internationalFormatted. - */ - java.lang.String getInternationalFormatted(); - /** - * string international_formatted = 4; - * @return The bytes for internationalFormatted. - */ - com.google.protobuf.ByteString - getInternationalFormattedBytes(); - - /** - * uint64 national = 5; - * @return The national. - */ - long getNational(); - - /** - * string national_formatted = 6; - * @return The nationalFormatted. - */ - java.lang.String getNationalFormatted(); - /** - * string national_formatted = 6; - * @return The bytes for nationalFormatted. - */ - com.google.protobuf.ByteString - getNationalFormattedBytes(); - - /** - * bool valid = 7; - * @return The valid. - */ - boolean getValid(); - } - /** - * Protobuf type {@code weaviate.v1.PhoneNumber} - */ - public static final class PhoneNumber extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PhoneNumber) - PhoneNumberOrBuilder { - private static final long serialVersionUID = 0L; - // Use PhoneNumber.newBuilder() to construct. - private PhoneNumber(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PhoneNumber() { - defaultCountry_ = ""; - input_ = ""; - internationalFormatted_ = ""; - nationalFormatted_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PhoneNumber(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder.class); - } - - public static final int COUNTRY_CODE_FIELD_NUMBER = 1; - private long countryCode_ = 0L; - /** - * uint64 country_code = 1; - * @return The countryCode. - */ - @java.lang.Override - public long getCountryCode() { - return countryCode_; - } - - public static final int DEFAULT_COUNTRY_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object defaultCountry_ = ""; - /** - * string default_country = 2; - * @return The defaultCountry. - */ - @java.lang.Override - public java.lang.String getDefaultCountry() { - java.lang.Object ref = defaultCountry_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - defaultCountry_ = s; - return s; - } - } - /** - * string default_country = 2; - * @return The bytes for defaultCountry. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getDefaultCountryBytes() { - java.lang.Object ref = defaultCountry_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - defaultCountry_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int INPUT_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object input_ = ""; - /** - * string input = 3; - * @return The input. - */ - @java.lang.Override - public java.lang.String getInput() { - java.lang.Object ref = input_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - input_ = s; - return s; - } - } - /** - * string input = 3; - * @return The bytes for input. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getInputBytes() { - java.lang.Object ref = input_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - input_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int INTERNATIONAL_FORMATTED_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private volatile java.lang.Object internationalFormatted_ = ""; - /** - * string international_formatted = 4; - * @return The internationalFormatted. - */ - @java.lang.Override - public java.lang.String getInternationalFormatted() { - java.lang.Object ref = internationalFormatted_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - internationalFormatted_ = s; - return s; - } - } - /** - * string international_formatted = 4; - * @return The bytes for internationalFormatted. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getInternationalFormattedBytes() { - java.lang.Object ref = internationalFormatted_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - internationalFormatted_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int NATIONAL_FIELD_NUMBER = 5; - private long national_ = 0L; - /** - * uint64 national = 5; - * @return The national. - */ - @java.lang.Override - public long getNational() { - return national_; - } - - public static final int NATIONAL_FORMATTED_FIELD_NUMBER = 6; - @SuppressWarnings("serial") - private volatile java.lang.Object nationalFormatted_ = ""; - /** - * string national_formatted = 6; - * @return The nationalFormatted. - */ - @java.lang.Override - public java.lang.String getNationalFormatted() { - java.lang.Object ref = nationalFormatted_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - nationalFormatted_ = s; - return s; - } - } - /** - * string national_formatted = 6; - * @return The bytes for nationalFormatted. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getNationalFormattedBytes() { - java.lang.Object ref = nationalFormatted_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - nationalFormatted_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int VALID_FIELD_NUMBER = 7; - private boolean valid_ = false; - /** - * bool valid = 7; - * @return The valid. - */ - @java.lang.Override - public boolean getValid() { - return valid_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (countryCode_ != 0L) { - output.writeUInt64(1, countryCode_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(defaultCountry_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, defaultCountry_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(input_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, input_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(internationalFormatted_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 4, internationalFormatted_); - } - if (national_ != 0L) { - output.writeUInt64(5, national_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(nationalFormatted_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 6, nationalFormatted_); - } - if (valid_ != false) { - output.writeBool(7, valid_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (countryCode_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeUInt64Size(1, countryCode_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(defaultCountry_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, defaultCountry_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(input_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, input_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(internationalFormatted_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, internationalFormatted_); - } - if (national_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeUInt64Size(5, national_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(nationalFormatted_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, nationalFormatted_); - } - if (valid_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(7, valid_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) obj; - - if (getCountryCode() - != other.getCountryCode()) return false; - if (!getDefaultCountry() - .equals(other.getDefaultCountry())) return false; - if (!getInput() - .equals(other.getInput())) return false; - if (!getInternationalFormatted() - .equals(other.getInternationalFormatted())) return false; - if (getNational() - != other.getNational()) return false; - if (!getNationalFormatted() - .equals(other.getNationalFormatted())) return false; - if (getValid() - != other.getValid()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + COUNTRY_CODE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getCountryCode()); - hash = (37 * hash) + DEFAULT_COUNTRY_FIELD_NUMBER; - hash = (53 * hash) + getDefaultCountry().hashCode(); - hash = (37 * hash) + INPUT_FIELD_NUMBER; - hash = (53 * hash) + getInput().hashCode(); - hash = (37 * hash) + INTERNATIONAL_FORMATTED_FIELD_NUMBER; - hash = (53 * hash) + getInternationalFormatted().hashCode(); - hash = (37 * hash) + NATIONAL_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getNational()); - hash = (37 * hash) + NATIONAL_FORMATTED_FIELD_NUMBER; - hash = (53 * hash) + getNationalFormatted().hashCode(); - hash = (37 * hash) + VALID_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getValid()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PhoneNumber} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PhoneNumber) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumberOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - countryCode_ = 0L; - defaultCountry_ = ""; - input_ = ""; - internationalFormatted_ = ""; - national_ = 0L; - nationalFormatted_ = ""; - valid_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.countryCode_ = countryCode_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.defaultCountry_ = defaultCountry_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.input_ = input_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.internationalFormatted_ = internationalFormatted_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.national_ = national_; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.nationalFormatted_ = nationalFormatted_; - } - if (((from_bitField0_ & 0x00000040) != 0)) { - result.valid_ = valid_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber.getDefaultInstance()) return this; - if (other.getCountryCode() != 0L) { - setCountryCode(other.getCountryCode()); - } - if (!other.getDefaultCountry().isEmpty()) { - defaultCountry_ = other.defaultCountry_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getInput().isEmpty()) { - input_ = other.input_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (!other.getInternationalFormatted().isEmpty()) { - internationalFormatted_ = other.internationalFormatted_; - bitField0_ |= 0x00000008; - onChanged(); - } - if (other.getNational() != 0L) { - setNational(other.getNational()); - } - if (!other.getNationalFormatted().isEmpty()) { - nationalFormatted_ = other.nationalFormatted_; - bitField0_ |= 0x00000020; - onChanged(); - } - if (other.getValid() != false) { - setValid(other.getValid()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - countryCode_ = input.readUInt64(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - defaultCountry_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - input_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 34: { - internationalFormatted_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000008; - break; - } // case 34 - case 40: { - national_ = input.readUInt64(); - bitField0_ |= 0x00000010; - break; - } // case 40 - case 50: { - nationalFormatted_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000020; - break; - } // case 50 - case 56: { - valid_ = input.readBool(); - bitField0_ |= 0x00000040; - break; - } // case 56 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private long countryCode_ ; - /** - * uint64 country_code = 1; - * @return The countryCode. - */ - @java.lang.Override - public long getCountryCode() { - return countryCode_; - } - /** - * uint64 country_code = 1; - * @param value The countryCode to set. - * @return This builder for chaining. - */ - public Builder setCountryCode(long value) { - - countryCode_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * uint64 country_code = 1; - * @return This builder for chaining. - */ - public Builder clearCountryCode() { - bitField0_ = (bitField0_ & ~0x00000001); - countryCode_ = 0L; - onChanged(); - return this; - } - - private java.lang.Object defaultCountry_ = ""; - /** - * string default_country = 2; - * @return The defaultCountry. - */ - public java.lang.String getDefaultCountry() { - java.lang.Object ref = defaultCountry_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - defaultCountry_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string default_country = 2; - * @return The bytes for defaultCountry. - */ - public com.google.protobuf.ByteString - getDefaultCountryBytes() { - java.lang.Object ref = defaultCountry_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - defaultCountry_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string default_country = 2; - * @param value The defaultCountry to set. - * @return This builder for chaining. - */ - public Builder setDefaultCountry( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - defaultCountry_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string default_country = 2; - * @return This builder for chaining. - */ - public Builder clearDefaultCountry() { - defaultCountry_ = getDefaultInstance().getDefaultCountry(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string default_country = 2; - * @param value The bytes for defaultCountry to set. - * @return This builder for chaining. - */ - public Builder setDefaultCountryBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - defaultCountry_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object input_ = ""; - /** - * string input = 3; - * @return The input. - */ - public java.lang.String getInput() { - java.lang.Object ref = input_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - input_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string input = 3; - * @return The bytes for input. - */ - public com.google.protobuf.ByteString - getInputBytes() { - java.lang.Object ref = input_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - input_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string input = 3; - * @param value The input to set. - * @return This builder for chaining. - */ - public Builder setInput( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - input_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string input = 3; - * @return This builder for chaining. - */ - public Builder clearInput() { - input_ = getDefaultInstance().getInput(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string input = 3; - * @param value The bytes for input to set. - * @return This builder for chaining. - */ - public Builder setInputBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - input_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private java.lang.Object internationalFormatted_ = ""; - /** - * string international_formatted = 4; - * @return The internationalFormatted. - */ - public java.lang.String getInternationalFormatted() { - java.lang.Object ref = internationalFormatted_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - internationalFormatted_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string international_formatted = 4; - * @return The bytes for internationalFormatted. - */ - public com.google.protobuf.ByteString - getInternationalFormattedBytes() { - java.lang.Object ref = internationalFormatted_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - internationalFormatted_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string international_formatted = 4; - * @param value The internationalFormatted to set. - * @return This builder for chaining. - */ - public Builder setInternationalFormatted( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - internationalFormatted_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * string international_formatted = 4; - * @return This builder for chaining. - */ - public Builder clearInternationalFormatted() { - internationalFormatted_ = getDefaultInstance().getInternationalFormatted(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - return this; - } - /** - * string international_formatted = 4; - * @param value The bytes for internationalFormatted to set. - * @return This builder for chaining. - */ - public Builder setInternationalFormattedBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - internationalFormatted_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - - private long national_ ; - /** - * uint64 national = 5; - * @return The national. - */ - @java.lang.Override - public long getNational() { - return national_; - } - /** - * uint64 national = 5; - * @param value The national to set. - * @return This builder for chaining. - */ - public Builder setNational(long value) { - - national_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * uint64 national = 5; - * @return This builder for chaining. - */ - public Builder clearNational() { - bitField0_ = (bitField0_ & ~0x00000010); - national_ = 0L; - onChanged(); - return this; - } - - private java.lang.Object nationalFormatted_ = ""; - /** - * string national_formatted = 6; - * @return The nationalFormatted. - */ - public java.lang.String getNationalFormatted() { - java.lang.Object ref = nationalFormatted_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - nationalFormatted_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string national_formatted = 6; - * @return The bytes for nationalFormatted. - */ - public com.google.protobuf.ByteString - getNationalFormattedBytes() { - java.lang.Object ref = nationalFormatted_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - nationalFormatted_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string national_formatted = 6; - * @param value The nationalFormatted to set. - * @return This builder for chaining. - */ - public Builder setNationalFormatted( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - nationalFormatted_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * string national_formatted = 6; - * @return This builder for chaining. - */ - public Builder clearNationalFormatted() { - nationalFormatted_ = getDefaultInstance().getNationalFormatted(); - bitField0_ = (bitField0_ & ~0x00000020); - onChanged(); - return this; - } - /** - * string national_formatted = 6; - * @param value The bytes for nationalFormatted to set. - * @return This builder for chaining. - */ - public Builder setNationalFormattedBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - nationalFormatted_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - - private boolean valid_ ; - /** - * bool valid = 7; - * @return The valid. - */ - @java.lang.Override - public boolean getValid() { - return valid_; - } - /** - * bool valid = 7; - * @param value The valid to set. - * @return This builder for chaining. - */ - public Builder setValid(boolean value) { - - valid_ = value; - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - * bool valid = 7; - * @return This builder for chaining. - */ - public Builder clearValid() { - bitField0_ = (bitField0_ & ~0x00000040); - valid_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PhoneNumber) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PhoneNumber) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PhoneNumber parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PhoneNumber getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_Properties_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_Properties_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_Properties_FieldsEntry_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_Properties_FieldsEntry_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_Value_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_Value_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ListValue_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ListValue_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_NumberValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_NumberValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_TextValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_TextValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_BoolValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_BoolValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ObjectValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ObjectValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_DateValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_DateValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_UuidValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_UuidValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_IntValues_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_IntValues_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GeoCoordinate_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PhoneNumber_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\023v1/properties.proto\022\013weaviate.v1\032\034goog" + - "le/protobuf/struct.proto\"\204\001\n\nProperties\022" + - "3\n\006fields\030\001 \003(\0132#.weaviate.v1.Properties" + - ".FieldsEntry\032A\n\013FieldsEntry\022\013\n\003key\030\001 \001(\t" + - "\022!\n\005value\030\002 \001(\0132\022.weaviate.v1.Value:\0028\001\"" + - "\235\003\n\005Value\022\026\n\014number_value\030\001 \001(\001H\000\022\024\n\nboo" + - "l_value\030\003 \001(\010H\000\022/\n\014object_value\030\004 \001(\0132\027." + - "weaviate.v1.PropertiesH\000\022,\n\nlist_value\030\005" + - " \001(\0132\026.weaviate.v1.ListValueH\000\022\024\n\ndate_v" + - "alue\030\006 \001(\tH\000\022\024\n\nuuid_value\030\007 \001(\tH\000\022\023\n\tin" + - "t_value\030\010 \001(\003H\000\022/\n\tgeo_value\030\t \001(\0132\032.wea" + - "viate.v1.GeoCoordinateH\000\022\024\n\nblob_value\030\n" + - " \001(\tH\000\022/\n\013phone_value\030\013 \001(\0132\030.weaviate.v" + - "1.PhoneNumberH\000\0220\n\nnull_value\030\014 \001(\0162\032.go" + - "ogle.protobuf.NullValueH\000\022\024\n\ntext_value\030" + - "\r \001(\tH\000B\006\n\004kind\"\357\002\n\tListValue\0222\n\rnumber_" + - "values\030\002 \001(\0132\031.weaviate.v1.NumberValuesH" + - "\000\022.\n\013bool_values\030\003 \001(\0132\027.weaviate.v1.Boo" + - "lValuesH\000\0222\n\robject_values\030\004 \001(\0132\031.weavi" + - "ate.v1.ObjectValuesH\000\022.\n\013date_values\030\005 \001" + - "(\0132\027.weaviate.v1.DateValuesH\000\022.\n\013uuid_va" + - "lues\030\006 \001(\0132\027.weaviate.v1.UuidValuesH\000\022,\n" + - "\nint_values\030\007 \001(\0132\026.weaviate.v1.IntValue" + - "sH\000\022.\n\013text_values\030\010 \001(\0132\027.weaviate.v1.T" + - "extValuesH\000B\006\n\004kindJ\004\010\001\020\002\"\036\n\014NumberValue" + - "s\022\016\n\006values\030\001 \001(\014\"\034\n\nTextValues\022\016\n\006value" + - "s\030\001 \003(\t\"\034\n\nBoolValues\022\016\n\006values\030\001 \003(\010\"7\n" + - "\014ObjectValues\022\'\n\006values\030\001 \003(\0132\027.weaviate" + - ".v1.Properties\"\034\n\nDateValues\022\016\n\006values\030\001" + - " \003(\t\"\034\n\nUuidValues\022\016\n\006values\030\001 \003(\t\"\033\n\tIn" + - "tValues\022\016\n\006values\030\001 \001(\014\"4\n\rGeoCoordinate" + - "\022\021\n\tlongitude\030\001 \001(\002\022\020\n\010latitude\030\002 \001(\002\"\251\001" + - "\n\013PhoneNumber\022\024\n\014country_code\030\001 \001(\004\022\027\n\017d" + - "efault_country\030\002 \001(\t\022\r\n\005input\030\003 \001(\t\022\037\n\027i" + - "nternational_formatted\030\004 \001(\t\022\020\n\010national" + - "\030\005 \001(\004\022\032\n\022national_formatted\030\006 \001(\t\022\r\n\005va" + - "lid\030\007 \001(\010Bt\n#io.weaviate.client.grpc.pro" + - "tocol.v1B\027WeaviateProtoPropertiesZ4githu" + - "b.com/weaviate/weaviate/grpc/generated;p" + - "rotocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - com.google.protobuf.StructProto.getDescriptor(), - }); - internal_static_weaviate_v1_Properties_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviate_v1_Properties_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_Properties_descriptor, - new java.lang.String[] { "Fields", }); - internal_static_weaviate_v1_Properties_FieldsEntry_descriptor = - internal_static_weaviate_v1_Properties_descriptor.getNestedTypes().get(0); - internal_static_weaviate_v1_Properties_FieldsEntry_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_Properties_FieldsEntry_descriptor, - new java.lang.String[] { "Key", "Value", }); - internal_static_weaviate_v1_Value_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviate_v1_Value_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_Value_descriptor, - new java.lang.String[] { "NumberValue", "BoolValue", "ObjectValue", "ListValue", "DateValue", "UuidValue", "IntValue", "GeoValue", "BlobValue", "PhoneValue", "NullValue", "TextValue", "Kind", }); - internal_static_weaviate_v1_ListValue_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_weaviate_v1_ListValue_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ListValue_descriptor, - new java.lang.String[] { "NumberValues", "BoolValues", "ObjectValues", "DateValues", "UuidValues", "IntValues", "TextValues", "Kind", }); - internal_static_weaviate_v1_NumberValues_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_weaviate_v1_NumberValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_NumberValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_TextValues_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_weaviate_v1_TextValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_TextValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_BoolValues_descriptor = - getDescriptor().getMessageTypes().get(5); - internal_static_weaviate_v1_BoolValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_BoolValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_ObjectValues_descriptor = - getDescriptor().getMessageTypes().get(6); - internal_static_weaviate_v1_ObjectValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ObjectValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_DateValues_descriptor = - getDescriptor().getMessageTypes().get(7); - internal_static_weaviate_v1_DateValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_DateValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_UuidValues_descriptor = - getDescriptor().getMessageTypes().get(8); - internal_static_weaviate_v1_UuidValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_UuidValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_IntValues_descriptor = - getDescriptor().getMessageTypes().get(9); - internal_static_weaviate_v1_IntValues_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_IntValues_descriptor, - new java.lang.String[] { "Values", }); - internal_static_weaviate_v1_GeoCoordinate_descriptor = - getDescriptor().getMessageTypes().get(10); - internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GeoCoordinate_descriptor, - new java.lang.String[] { "Longitude", "Latitude", }); - internal_static_weaviate_v1_PhoneNumber_descriptor = - getDescriptor().getMessageTypes().get(11); - internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PhoneNumber_descriptor, - new java.lang.String[] { "CountryCode", "DefaultCountry", "Input", "InternationalFormatted", "National", "NationalFormatted", "Valid", }); - com.google.protobuf.StructProto.getDescriptor(); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoReplicate.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoReplicate.java deleted file mode 100644 index ed010bb33..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoReplicate.java +++ /dev/null @@ -1,8342 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/file_replication.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateProtoReplicate { - private WeaviateProtoReplicate() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - /** - * Protobuf enum {@code weaviate.v1.CompressionType} - */ - public enum CompressionType - implements com.google.protobuf.ProtocolMessageEnum { - /** - *
-     * No compression
-     * 
- * - * COMPRESSION_TYPE_UNSPECIFIED = 0; - */ - COMPRESSION_TYPE_UNSPECIFIED(0), - /** - *
-     * gzip (compress/gzip)
-     * 
- * - * COMPRESSION_TYPE_GZIP = 1; - */ - COMPRESSION_TYPE_GZIP(1), - /** - *
-     * zlib (compress/zlib)
-     * 
- * - * COMPRESSION_TYPE_ZLIB = 2; - */ - COMPRESSION_TYPE_ZLIB(2), - /** - *
-     * raw DEFLATE (compress/flate)
-     * 
- * - * COMPRESSION_TYPE_DEFLATE = 3; - */ - COMPRESSION_TYPE_DEFLATE(3), - UNRECOGNIZED(-1), - ; - - /** - *
-     * No compression
-     * 
- * - * COMPRESSION_TYPE_UNSPECIFIED = 0; - */ - public static final int COMPRESSION_TYPE_UNSPECIFIED_VALUE = 0; - /** - *
-     * gzip (compress/gzip)
-     * 
- * - * COMPRESSION_TYPE_GZIP = 1; - */ - public static final int COMPRESSION_TYPE_GZIP_VALUE = 1; - /** - *
-     * zlib (compress/zlib)
-     * 
- * - * COMPRESSION_TYPE_ZLIB = 2; - */ - public static final int COMPRESSION_TYPE_ZLIB_VALUE = 2; - /** - *
-     * raw DEFLATE (compress/flate)
-     * 
- * - * COMPRESSION_TYPE_DEFLATE = 3; - */ - public static final int COMPRESSION_TYPE_DEFLATE_VALUE = 3; - - - public final int getNumber() { - if (this == UNRECOGNIZED) { - throw new java.lang.IllegalArgumentException( - "Can't get the number of an unknown enum value."); - } - return value; - } - - /** - * @param value The numeric wire value of the corresponding enum entry. - * @return The enum associated with the given numeric wire value. - * @deprecated Use {@link #forNumber(int)} instead. - */ - @java.lang.Deprecated - public static CompressionType valueOf(int value) { - return forNumber(value); - } - - /** - * @param value The numeric wire value of the corresponding enum entry. - * @return The enum associated with the given numeric wire value. - */ - public static CompressionType forNumber(int value) { - switch (value) { - case 0: return COMPRESSION_TYPE_UNSPECIFIED; - case 1: return COMPRESSION_TYPE_GZIP; - case 2: return COMPRESSION_TYPE_ZLIB; - case 3: return COMPRESSION_TYPE_DEFLATE; - default: return null; - } - } - - public static com.google.protobuf.Internal.EnumLiteMap - internalGetValueMap() { - return internalValueMap; - } - private static final com.google.protobuf.Internal.EnumLiteMap< - CompressionType> internalValueMap = - new com.google.protobuf.Internal.EnumLiteMap() { - public CompressionType findValueByNumber(int number) { - return CompressionType.forNumber(number); - } - }; - - public final com.google.protobuf.Descriptors.EnumValueDescriptor - getValueDescriptor() { - if (this == UNRECOGNIZED) { - throw new java.lang.IllegalStateException( - "Can't get the descriptor of an unrecognized enum value."); - } - return getDescriptor().getValues().get(ordinal()); - } - public final com.google.protobuf.Descriptors.EnumDescriptor - getDescriptorForType() { - return getDescriptor(); - } - public static final com.google.protobuf.Descriptors.EnumDescriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.getDescriptor().getEnumTypes().get(0); - } - - private static final CompressionType[] VALUES = values(); - - public static CompressionType valueOf( - com.google.protobuf.Descriptors.EnumValueDescriptor desc) { - if (desc.getType() != getDescriptor()) { - throw new java.lang.IllegalArgumentException( - "EnumValueDescriptor is not for this type."); - } - if (desc.getIndex() == -1) { - return UNRECOGNIZED; - } - return VALUES[desc.getIndex()]; - } - - private final int value; - - private CompressionType(int value) { - this.value = value; - } - - // @@protoc_insertion_point(enum_scope:weaviate.v1.CompressionType) - } - - public interface PauseFileActivityRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - long getSchemaVersion(); - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} - */ - public static final class PauseFileActivityRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityRequest) - PauseFileActivityRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use PauseFileActivityRequest.newBuilder() to construct. - private PauseFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PauseFileActivityRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PauseFileActivityRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SCHEMA_VERSION_FIELD_NUMBER = 3; - private long schemaVersion_ = 0L; - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - @java.lang.Override - public long getSchemaVersion() { - return schemaVersion_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (schemaVersion_ != 0L) { - output.writeUInt64(3, schemaVersion_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (schemaVersion_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeUInt64Size(3, schemaVersion_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (getSchemaVersion() - != other.getSchemaVersion()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + SCHEMA_VERSION_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getSchemaVersion()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - schemaVersion_ = 0L; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.schemaVersion_ = schemaVersion_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (other.getSchemaVersion() != 0L) { - setSchemaVersion(other.getSchemaVersion()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 24: { - schemaVersion_ = input.readUInt64(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private long schemaVersion_ ; - /** - * uint64 schema_version = 3; - * @return The schemaVersion. - */ - @java.lang.Override - public long getSchemaVersion() { - return schemaVersion_; - } - /** - * uint64 schema_version = 3; - * @param value The schemaVersion to set. - * @return This builder for chaining. - */ - public Builder setSchemaVersion(long value) { - - schemaVersion_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * uint64 schema_version = 3; - * @return This builder for chaining. - */ - public Builder clearSchemaVersion() { - bitField0_ = (bitField0_ & ~0x00000004); - schemaVersion_ = 0L; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PauseFileActivityRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface PauseFileActivityResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} - */ - public static final class PauseFileActivityResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityResponse) - PauseFileActivityResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use PauseFileActivityResponse.newBuilder() to construct. - private PauseFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PauseFileActivityResponse() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PauseFileActivityResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PauseFileActivityResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.PauseFileActivityResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ResumeFileActivityRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} - */ - public static final class ResumeFileActivityRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityRequest) - ResumeFileActivityRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use ResumeFileActivityRequest.newBuilder() to construct. - private ResumeFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ResumeFileActivityRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ResumeFileActivityRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ResumeFileActivityRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ResumeFileActivityResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} - */ - public static final class ResumeFileActivityResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityResponse) - ResumeFileActivityResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use ResumeFileActivityResponse.newBuilder() to construct. - private ResumeFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ResumeFileActivityResponse() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ResumeFileActivityResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ResumeFileActivityResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ResumeFileActivityResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ListFilesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.ListFilesRequest} - */ - public static final class ListFilesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesRequest) - ListFilesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use ListFilesRequest.newBuilder() to construct. - private ListFilesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ListFilesRequest() { - indexName_ = ""; - shardName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ListFilesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ListFilesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ListFilesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ListFilesResponseOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesResponse) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - java.util.List - getFileNamesList(); - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - int getFileNamesCount(); - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - java.lang.String getFileNames(int index); - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - com.google.protobuf.ByteString - getFileNamesBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.ListFilesResponse} - */ - public static final class ListFilesResponse extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesResponse) - ListFilesResponseOrBuilder { - private static final long serialVersionUID = 0L; - // Use ListFilesResponse.newBuilder() to construct. - private ListFilesResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ListFilesResponse() { - indexName_ = ""; - shardName_ = ""; - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ListFilesResponse(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAMES_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - public com.google.protobuf.ProtocolStringList - getFileNamesList() { - return fileNames_; - } - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - public int getFileNamesCount() { - return fileNames_.size(); - } - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - public java.lang.String getFileNames(int index) { - return fileNames_.get(index); - } - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - public com.google.protobuf.ByteString - getFileNamesBytes(int index) { - return fileNames_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - for (int i = 0; i < fileNames_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileNames_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - { - int dataSize = 0; - for (int i = 0; i < fileNames_.size(); i++) { - dataSize += computeStringSizeNoTag(fileNames_.getRaw(i)); - } - size += dataSize; - size += 1 * getFileNamesList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileNamesList() - .equals(other.getFileNamesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - if (getFileNamesCount() > 0) { - hash = (37 * hash) + FILE_NAMES_FIELD_NUMBER; - hash = (53 * hash) + getFileNamesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ListFilesResponse} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesResponse) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponseOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_ListFilesResponse_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - fileNames_.makeImmutable(); - result.fileNames_ = fileNames_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.fileNames_.isEmpty()) { - if (fileNames_.isEmpty()) { - fileNames_ = other.fileNames_; - bitField0_ |= 0x00000004; - } else { - ensureFileNamesIsMutable(); - fileNames_.addAll(other.fileNames_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - java.lang.String s = input.readStringRequireUtf8(); - ensureFileNamesIsMutable(); - fileNames_.add(s); - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private com.google.protobuf.LazyStringArrayList fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureFileNamesIsMutable() { - if (!fileNames_.isModifiable()) { - fileNames_ = new com.google.protobuf.LazyStringArrayList(fileNames_); - } - bitField0_ |= 0x00000004; - } - /** - * repeated string file_names = 3; - * @return A list containing the fileNames. - */ - public com.google.protobuf.ProtocolStringList - getFileNamesList() { - fileNames_.makeImmutable(); - return fileNames_; - } - /** - * repeated string file_names = 3; - * @return The count of fileNames. - */ - public int getFileNamesCount() { - return fileNames_.size(); - } - /** - * repeated string file_names = 3; - * @param index The index of the element to return. - * @return The fileNames at the given index. - */ - public java.lang.String getFileNames(int index) { - return fileNames_.get(index); - } - /** - * repeated string file_names = 3; - * @param index The index of the value to return. - * @return The bytes of the fileNames at the given index. - */ - public com.google.protobuf.ByteString - getFileNamesBytes(int index) { - return fileNames_.getByteString(index); - } - /** - * repeated string file_names = 3; - * @param index The index to set the value at. - * @param value The fileNames to set. - * @return This builder for chaining. - */ - public Builder setFileNames( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureFileNamesIsMutable(); - fileNames_.set(index, value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param value The fileNames to add. - * @return This builder for chaining. - */ - public Builder addFileNames( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureFileNamesIsMutable(); - fileNames_.add(value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param values The fileNames to add. - * @return This builder for chaining. - */ - public Builder addAllFileNames( - java.lang.Iterable values) { - ensureFileNamesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, fileNames_); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @return This builder for chaining. - */ - public Builder clearFileNames() { - fileNames_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000004);; - onChanged(); - return this; - } - /** - * repeated string file_names = 3; - * @param value The bytes of the fileNames to add. - * @return This builder for chaining. - */ - public Builder addFileNamesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureFileNamesIsMutable(); - fileNames_.add(value); - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesResponse) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesResponse) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ListFilesResponse parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.ListFilesResponse getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GetFileMetadataRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileMetadataRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} - */ - public static final class GetFileMetadataRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileMetadataRequest) - GetFileMetadataRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use GetFileMetadataRequest.newBuilder() to construct. - private GetFileMetadataRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GetFileMetadataRequest() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GetFileMetadataRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileMetadataRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileMetadataRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileMetadataRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GetFileMetadataRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileMetadataRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface FileMetadataOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.FileMetadata) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - - /** - * int64 size = 4; - * @return The size. - */ - long getSize(); - - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - int getCrc32(); - } - /** - * Protobuf type {@code weaviate.v1.FileMetadata} - */ - public static final class FileMetadata extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.FileMetadata) - FileMetadataOrBuilder { - private static final long serialVersionUID = 0L; - // Use FileMetadata.newBuilder() to construct. - private FileMetadata(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private FileMetadata() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new FileMetadata(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SIZE_FIELD_NUMBER = 4; - private long size_ = 0L; - /** - * int64 size = 4; - * @return The size. - */ - @java.lang.Override - public long getSize() { - return size_; - } - - public static final int CRC32_FIELD_NUMBER = 5; - private int crc32_ = 0; - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - @java.lang.Override - public int getCrc32() { - return crc32_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - if (size_ != 0L) { - output.writeInt64(4, size_); - } - if (crc32_ != 0) { - output.writeUInt32(5, crc32_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - if (size_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(4, size_); - } - if (crc32_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeUInt32Size(5, crc32_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (getSize() - != other.getSize()) return false; - if (getCrc32() - != other.getCrc32()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (37 * hash) + SIZE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getSize()); - hash = (37 * hash) + CRC32_FIELD_NUMBER; - hash = (53 * hash) + getCrc32(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.FileMetadata} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.FileMetadata) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadataOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - size_ = 0L; - crc32_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileMetadata_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.size_ = size_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.crc32_ = crc32_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (other.getSize() != 0L) { - setSize(other.getSize()); - } - if (other.getCrc32() != 0) { - setCrc32(other.getCrc32()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 32: { - size_ = input.readInt64(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 40: { - crc32_ = input.readUInt32(); - bitField0_ |= 0x00000010; - break; - } // case 40 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private long size_ ; - /** - * int64 size = 4; - * @return The size. - */ - @java.lang.Override - public long getSize() { - return size_; - } - /** - * int64 size = 4; - * @param value The size to set. - * @return This builder for chaining. - */ - public Builder setSize(long value) { - - size_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * int64 size = 4; - * @return This builder for chaining. - */ - public Builder clearSize() { - bitField0_ = (bitField0_ & ~0x00000008); - size_ = 0L; - onChanged(); - return this; - } - - private int crc32_ ; - /** - * uint32 crc32 = 5; - * @return The crc32. - */ - @java.lang.Override - public int getCrc32() { - return crc32_; - } - /** - * uint32 crc32 = 5; - * @param value The crc32 to set. - * @return This builder for chaining. - */ - public Builder setCrc32(int value) { - - crc32_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * uint32 crc32 = 5; - * @return This builder for chaining. - */ - public Builder clearCrc32() { - bitField0_ = (bitField0_ & ~0x00000010); - crc32_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.FileMetadata) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.FileMetadata) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public FileMetadata parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileMetadata getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GetFileRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string index_name = 1; - * @return The indexName. - */ - java.lang.String getIndexName(); - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - com.google.protobuf.ByteString - getIndexNameBytes(); - - /** - * string shard_name = 2; - * @return The shardName. - */ - java.lang.String getShardName(); - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - com.google.protobuf.ByteString - getShardNameBytes(); - - /** - * string file_name = 3; - * @return The fileName. - */ - java.lang.String getFileName(); - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - com.google.protobuf.ByteString - getFileNameBytes(); - - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - int getCompressionValue(); - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType getCompression(); - } - /** - * Protobuf type {@code weaviate.v1.GetFileRequest} - */ - public static final class GetFileRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileRequest) - GetFileRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use GetFileRequest.newBuilder() to construct. - private GetFileRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GetFileRequest() { - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - compression_ = 0; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GetFileRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.Builder.class); - } - - public static final int INDEX_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - @java.lang.Override - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SHARD_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - @java.lang.Override - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int FILE_NAME_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - @java.lang.Override - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int COMPRESSION_FIELD_NUMBER = 4; - private int compression_ = 0; - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - @java.lang.Override public int getCompressionValue() { - return compression_; - } - /** - *
-     * Requested compression algorithm for streamed chunks
-     * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType getCompression() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.forNumber(compression_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.UNRECOGNIZED : result; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); - } - if (compression_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { - output.writeEnum(4, compression_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); - } - if (compression_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(4, compression_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest) obj; - - if (!getIndexName() - .equals(other.getIndexName())) return false; - if (!getShardName() - .equals(other.getShardName())) return false; - if (!getFileName() - .equals(other.getFileName())) return false; - if (compression_ != other.compression_) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; - hash = (53 * hash) + getIndexName().hashCode(); - hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; - hash = (53 * hash) + getShardName().hashCode(); - hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; - hash = (53 * hash) + getFileName().hashCode(); - hash = (37 * hash) + COMPRESSION_FIELD_NUMBER; - hash = (53 * hash) + compression_; - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GetFileRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - indexName_ = ""; - shardName_ = ""; - fileName_ = ""; - compression_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_GetFileRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.indexName_ = indexName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.shardName_ = shardName_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.fileName_ = fileName_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.compression_ = compression_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest.getDefaultInstance()) return this; - if (!other.getIndexName().isEmpty()) { - indexName_ = other.indexName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getShardName().isEmpty()) { - shardName_ = other.shardName_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (!other.getFileName().isEmpty()) { - fileName_ = other.fileName_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (other.compression_ != 0) { - setCompressionValue(other.getCompressionValue()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - indexName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - shardName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - fileName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 32: { - compression_ = input.readEnum(); - bitField0_ |= 0x00000008; - break; - } // case 32 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object indexName_ = ""; - /** - * string index_name = 1; - * @return The indexName. - */ - public java.lang.String getIndexName() { - java.lang.Object ref = indexName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - indexName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string index_name = 1; - * @return The bytes for indexName. - */ - public com.google.protobuf.ByteString - getIndexNameBytes() { - java.lang.Object ref = indexName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - indexName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string index_name = 1; - * @param value The indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string index_name = 1; - * @return This builder for chaining. - */ - public Builder clearIndexName() { - indexName_ = getDefaultInstance().getIndexName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string index_name = 1; - * @param value The bytes for indexName to set. - * @return This builder for chaining. - */ - public Builder setIndexNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - indexName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object shardName_ = ""; - /** - * string shard_name = 2; - * @return The shardName. - */ - public java.lang.String getShardName() { - java.lang.Object ref = shardName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - shardName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string shard_name = 2; - * @return The bytes for shardName. - */ - public com.google.protobuf.ByteString - getShardNameBytes() { - java.lang.Object ref = shardName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - shardName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string shard_name = 2; - * @param value The shardName to set. - * @return This builder for chaining. - */ - public Builder setShardName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @return This builder for chaining. - */ - public Builder clearShardName() { - shardName_ = getDefaultInstance().getShardName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string shard_name = 2; - * @param value The bytes for shardName to set. - * @return This builder for chaining. - */ - public Builder setShardNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - shardName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.lang.Object fileName_ = ""; - /** - * string file_name = 3; - * @return The fileName. - */ - public java.lang.String getFileName() { - java.lang.Object ref = fileName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - fileName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string file_name = 3; - * @return The bytes for fileName. - */ - public com.google.protobuf.ByteString - getFileNameBytes() { - java.lang.Object ref = fileName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - fileName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string file_name = 3; - * @param value The fileName to set. - * @return This builder for chaining. - */ - public Builder setFileName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * string file_name = 3; - * @return This builder for chaining. - */ - public Builder clearFileName() { - fileName_ = getDefaultInstance().getFileName(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * string file_name = 3; - * @param value The bytes for fileName to set. - * @return This builder for chaining. - */ - public Builder setFileNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - fileName_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private int compression_ = 0; - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The enum numeric value on the wire for compression. - */ - @java.lang.Override public int getCompressionValue() { - return compression_; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @param value The enum numeric value on the wire for compression to set. - * @return This builder for chaining. - */ - public Builder setCompressionValue(int value) { - compression_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return The compression. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType getCompression() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.forNumber(compression_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType.UNRECOGNIZED : result; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @param value The compression to set. - * @return This builder for chaining. - */ - public Builder setCompression(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.CompressionType value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000008; - compression_ = value.getNumber(); - onChanged(); - return this; - } - /** - *
-       * Requested compression algorithm for streamed chunks
-       * 
- * - * .weaviate.v1.CompressionType compression = 4; - * @return This builder for chaining. - */ - public Builder clearCompression() { - bitField0_ = (bitField0_ & ~0x00000008); - compression_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GetFileRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.GetFileRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface FileChunkOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.FileChunk) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     * Byte offset in the uncompressed file
-     * 
- * - * int64 offset = 1; - * @return The offset. - */ - long getOffset(); - - /** - *
-     * Compressed or raw chunk data
-     * 
- * - * bytes data = 2; - * @return The data. - */ - com.google.protobuf.ByteString getData(); - - /** - *
-     * Indicates final chunk
-     * 
- * - * bool eof = 3; - * @return The eof. - */ - boolean getEof(); - } - /** - * Protobuf type {@code weaviate.v1.FileChunk} - */ - public static final class FileChunk extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.FileChunk) - FileChunkOrBuilder { - private static final long serialVersionUID = 0L; - // Use FileChunk.newBuilder() to construct. - private FileChunk(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private FileChunk() { - data_ = com.google.protobuf.ByteString.EMPTY; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new FileChunk(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileChunk_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.Builder.class); - } - - public static final int OFFSET_FIELD_NUMBER = 1; - private long offset_ = 0L; - /** - *
-     * Byte offset in the uncompressed file
-     * 
- * - * int64 offset = 1; - * @return The offset. - */ - @java.lang.Override - public long getOffset() { - return offset_; - } - - public static final int DATA_FIELD_NUMBER = 2; - private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-     * Compressed or raw chunk data
-     * 
- * - * bytes data = 2; - * @return The data. - */ - @java.lang.Override - public com.google.protobuf.ByteString getData() { - return data_; - } - - public static final int EOF_FIELD_NUMBER = 3; - private boolean eof_ = false; - /** - *
-     * Indicates final chunk
-     * 
- * - * bool eof = 3; - * @return The eof. - */ - @java.lang.Override - public boolean getEof() { - return eof_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (offset_ != 0L) { - output.writeInt64(1, offset_); - } - if (!data_.isEmpty()) { - output.writeBytes(2, data_); - } - if (eof_ != false) { - output.writeBool(3, eof_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (offset_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(1, offset_); - } - if (!data_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(2, data_); - } - if (eof_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(3, eof_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk) obj; - - if (getOffset() - != other.getOffset()) return false; - if (!getData() - .equals(other.getData())) return false; - if (getEof() - != other.getEof()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + OFFSET_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getOffset()); - hash = (37 * hash) + DATA_FIELD_NUMBER; - hash = (53 * hash) + getData().hashCode(); - hash = (37 * hash) + EOF_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getEof()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.FileChunk} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.FileChunk) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunkOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileChunk_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - offset_ = 0L; - data_ = com.google.protobuf.ByteString.EMPTY; - eof_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.internal_static_weaviate_v1_FileChunk_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.offset_ = offset_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.data_ = data_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.eof_ = eof_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk.getDefaultInstance()) return this; - if (other.getOffset() != 0L) { - setOffset(other.getOffset()); - } - if (other.getData() != com.google.protobuf.ByteString.EMPTY) { - setData(other.getData()); - } - if (other.getEof() != false) { - setEof(other.getEof()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - offset_ = input.readInt64(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - data_ = input.readBytes(); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 24: { - eof_ = input.readBool(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private long offset_ ; - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @return The offset. - */ - @java.lang.Override - public long getOffset() { - return offset_; - } - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @param value The offset to set. - * @return This builder for chaining. - */ - public Builder setOffset(long value) { - - offset_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       * Byte offset in the uncompressed file
-       * 
- * - * int64 offset = 1; - * @return This builder for chaining. - */ - public Builder clearOffset() { - bitField0_ = (bitField0_ & ~0x00000001); - offset_ = 0L; - onChanged(); - return this; - } - - private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @return The data. - */ - @java.lang.Override - public com.google.protobuf.ByteString getData() { - return data_; - } - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @param value The data to set. - * @return This builder for chaining. - */ - public Builder setData(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - data_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * Compressed or raw chunk data
-       * 
- * - * bytes data = 2; - * @return This builder for chaining. - */ - public Builder clearData() { - bitField0_ = (bitField0_ & ~0x00000002); - data_ = getDefaultInstance().getData(); - onChanged(); - return this; - } - - private boolean eof_ ; - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @return The eof. - */ - @java.lang.Override - public boolean getEof() { - return eof_; - } - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @param value The eof to set. - * @return This builder for chaining. - */ - public Builder setEof(boolean value) { - - eof_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - *
-       * Indicates final chunk
-       * 
- * - * bool eof = 3; - * @return This builder for chaining. - */ - public Builder clearEof() { - bitField0_ = (bitField0_ & ~0x00000004); - eof_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.FileChunk) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.FileChunk) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public FileChunk parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoReplicate.FileChunk getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ListFilesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ListFilesResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_FileMetadata_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_FileMetadata_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GetFileRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_FileChunk_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_FileChunk_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\031v1/file_replication.proto\022\013weaviate.v1" + - "\"Z\n\030PauseFileActivityRequest\022\022\n\nindex_na" + - "me\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\026\n\016schema_v" + - "ersion\030\003 \001(\004\"C\n\031PauseFileActivityRespons" + - "e\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(" + - "\t\"C\n\031ResumeFileActivityRequest\022\022\n\nindex_" + - "name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\"D\n\032Resume" + - "FileActivityResponse\022\022\n\nindex_name\030\001 \001(\t" + - "\022\022\n\nshard_name\030\002 \001(\t\":\n\020ListFilesRequest" + - "\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t" + - "\"O\n\021ListFilesResponse\022\022\n\nindex_name\030\001 \001(" + - "\t\022\022\n\nshard_name\030\002 \001(\t\022\022\n\nfile_names\030\003 \003(" + - "\t\"S\n\026GetFileMetadataRequest\022\022\n\nindex_nam" + - "e\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name" + - "\030\003 \001(\t\"f\n\014FileMetadata\022\022\n\nindex_name\030\001 \001" + - "(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(" + - "\t\022\014\n\004size\030\004 \001(\003\022\r\n\005crc32\030\005 \001(\r\"~\n\016GetFil" + - "eRequest\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_na" + - "me\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(\t\0221\n\013compressi" + - "on\030\004 \001(\0162\034.weaviate.v1.CompressionType\"6" + - "\n\tFileChunk\022\016\n\006offset\030\001 \001(\003\022\014\n\004data\030\002 \001(" + - "\014\022\013\n\003eof\030\003 \001(\010*\207\001\n\017CompressionType\022 \n\034CO" + - "MPRESSION_TYPE_UNSPECIFIED\020\000\022\031\n\025COMPRESS" + - "ION_TYPE_GZIP\020\001\022\031\n\025COMPRESSION_TYPE_ZLIB" + - "\020\002\022\034\n\030COMPRESSION_TYPE_DEFLATE\020\0032\312\003\n\026Fil" + - "eReplicationService\022b\n\021PauseFileActivity" + - "\022%.weaviate.v1.PauseFileActivityRequest\032" + - "&.weaviate.v1.PauseFileActivityResponse\022" + - "e\n\022ResumeFileActivity\022&.weaviate.v1.Resu" + - "meFileActivityRequest\032\'.weaviate.v1.Resu" + - "meFileActivityResponse\022J\n\tListFiles\022\035.we" + - "aviate.v1.ListFilesRequest\032\036.weaviate.v1" + - ".ListFilesResponse\022U\n\017GetFileMetadata\022#." + - "weaviate.v1.GetFileMetadataRequest\032\031.wea" + - "viate.v1.FileMetadata(\0010\001\022B\n\007GetFile\022\033.w" + - "eaviate.v1.GetFileRequest\032\026.weaviate.v1." + - "FileChunk(\0010\001Bs\n#io.weaviate.client.grpc" + - ".protocol.v1B\026WeaviateProtoReplicateZ4gi" + - "thub.com/weaviate/weaviate/grpc/generate" + - "d;protocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - }); - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PauseFileActivityRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "SchemaVersion", }); - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PauseFileActivityResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ListFilesRequest_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ListFilesRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", }); - internal_static_weaviate_v1_ListFilesResponse_descriptor = - getDescriptor().getMessageTypes().get(5); - internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ListFilesResponse_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileNames", }); - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor = - getDescriptor().getMessageTypes().get(6); - internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GetFileMetadataRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", }); - internal_static_weaviate_v1_FileMetadata_descriptor = - getDescriptor().getMessageTypes().get(7); - internal_static_weaviate_v1_FileMetadata_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_FileMetadata_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", "Size", "Crc32", }); - internal_static_weaviate_v1_GetFileRequest_descriptor = - getDescriptor().getMessageTypes().get(8); - internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GetFileRequest_descriptor, - new java.lang.String[] { "IndexName", "ShardName", "FileName", "Compression", }); - internal_static_weaviate_v1_FileChunk_descriptor = - getDescriptor().getMessageTypes().get(9); - internal_static_weaviate_v1_FileChunk_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_FileChunk_descriptor, - new java.lang.String[] { "Offset", "Data", "Eof", }); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoSearchGet.java b/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoSearchGet.java deleted file mode 100644 index 25591ca56..000000000 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoSearchGet.java +++ /dev/null @@ -1,23355 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: v1/search_get.proto - -package io.weaviate.client.grpc.protocol.v1; - -public final class WeaviateProtoSearchGet { - private WeaviateProtoSearchGet() {} - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { - } - - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { - registerAllExtensions( - (com.google.protobuf.ExtensionRegistryLite) registry); - } - public interface SearchRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchRequest) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     *required
-     * 
- * - * string collection = 1; - * @return The collection. - */ - java.lang.String getCollection(); - /** - *
-     *required
-     * 
- * - * string collection = 1; - * @return The bytes for collection. - */ - com.google.protobuf.ByteString - getCollectionBytes(); - - /** - *
-     * parameters
-     * 
- * - * string tenant = 10; - * @return The tenant. - */ - java.lang.String getTenant(); - /** - *
-     * parameters
-     * 
- * - * string tenant = 10; - * @return The bytes for tenant. - */ - com.google.protobuf.ByteString - getTenantBytes(); - - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return Whether the consistencyLevel field is set. - */ - boolean hasConsistencyLevel(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The enum numeric value on the wire for consistencyLevel. - */ - int getConsistencyLevelValue(); - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The consistencyLevel. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); - - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return Whether the properties field is set. - */ - boolean hasProperties(); - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return The properties. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties(); - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder(); - - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return Whether the metadata field is set. - */ - boolean hasMetadata(); - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return The metadata. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata(); - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder(); - - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return Whether the groupBy field is set. - */ - boolean hasGroupBy(); - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return The groupBy. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getGroupBy(); - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder(); - - /** - *
-     * affects order and length of results. 0/empty (default value) means disabled
-     * 
- * - * uint32 limit = 30; - * @return The limit. - */ - int getLimit(); - - /** - * uint32 offset = 31; - * @return The offset. - */ - int getOffset(); - - /** - * uint32 autocut = 32; - * @return The autocut. - */ - int getAutocut(); - - /** - * string after = 33; - * @return The after. - */ - java.lang.String getAfter(); - /** - * string after = 33; - * @return The bytes for after. - */ - com.google.protobuf.ByteString - getAfterBytes(); - - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - java.util.List - getSortByList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getSortBy(int index); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - int getSortByCount(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - java.util.List - getSortByOrBuilderList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( - int index); - - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return Whether the filters field is set. - */ - boolean hasFilters(); - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return The filters. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(); - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(); - - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return Whether the hybridSearch field is set. - */ - boolean hasHybridSearch(); - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return The hybridSearch. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybridSearch(); - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder(); - - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return Whether the bm25Search field is set. - */ - boolean hasBm25Search(); - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return The bm25Search. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getBm25Search(); - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder(); - - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return Whether the nearVector field is set. - */ - boolean hasNearVector(); - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return The nearVector. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector(); - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder(); - - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return Whether the nearObject field is set. - */ - boolean hasNearObject(); - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return The nearObject. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject(); - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder(); - - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return Whether the nearText field is set. - */ - boolean hasNearText(); - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return The nearText. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText(); - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder(); - - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return Whether the nearImage field is set. - */ - boolean hasNearImage(); - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return The nearImage. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage(); - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder(); - - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return Whether the nearAudio field is set. - */ - boolean hasNearAudio(); - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return The nearAudio. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio(); - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder(); - - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return Whether the nearVideo field is set. - */ - boolean hasNearVideo(); - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return The nearVideo. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo(); - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder(); - - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return Whether the nearDepth field is set. - */ - boolean hasNearDepth(); - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return The nearDepth. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth(); - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder(); - - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return Whether the nearThermal field is set. - */ - boolean hasNearThermal(); - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return The nearThermal. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal(); - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder(); - - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return Whether the nearImu field is set. - */ - boolean hasNearImu(); - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return The nearImu. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu(); - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder(); - - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return Whether the generative field is set. - */ - boolean hasGenerative(); - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return The generative. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getGenerative(); - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder(); - - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return Whether the rerank field is set. - */ - boolean hasRerank(); - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return The rerank. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getRerank(); - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder(); - - /** - * bool uses_123_api = 100 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. - * See v1/search_get.proto;l=51 - * @return The uses123Api. - */ - @java.lang.Deprecated boolean getUses123Api(); - - /** - * bool uses_125_api = 101 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. - * See v1/search_get.proto;l=52 - * @return The uses125Api. - */ - @java.lang.Deprecated boolean getUses125Api(); - - /** - * bool uses_127_api = 102; - * @return The uses127Api. - */ - boolean getUses127Api(); - } - /** - * Protobuf type {@code weaviate.v1.SearchRequest} - */ - public static final class SearchRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.SearchRequest) - SearchRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use SearchRequest.newBuilder() to construct. - private SearchRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SearchRequest() { - collection_ = ""; - tenant_ = ""; - consistencyLevel_ = 0; - after_ = ""; - sortBy_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SearchRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.Builder.class); - } - - private int bitField0_; - public static final int COLLECTION_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object collection_ = ""; - /** - *
-     *required
-     * 
- * - * string collection = 1; - * @return The collection. - */ - @java.lang.Override - public java.lang.String getCollection() { - java.lang.Object ref = collection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - collection_ = s; - return s; - } - } - /** - *
-     *required
-     * 
- * - * string collection = 1; - * @return The bytes for collection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getCollectionBytes() { - java.lang.Object ref = collection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - collection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int TENANT_FIELD_NUMBER = 10; - @SuppressWarnings("serial") - private volatile java.lang.Object tenant_ = ""; - /** - *
-     * parameters
-     * 
- * - * string tenant = 10; - * @return The tenant. - */ - @java.lang.Override - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } - } - /** - *
-     * parameters
-     * 
- * - * string tenant = 10; - * @return The bytes for tenant. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 11; - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The consistencyLevel. - */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - - public static final int PROPERTIES_FIELD_NUMBER = 20; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest properties_; - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return Whether the properties field is set. - */ - @java.lang.Override - public boolean hasProperties() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return The properties. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - /** - *
-     * what is returned
-     * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - - public static final int METADATA_FIELD_NUMBER = 21; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest metadata_; - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return Whether the metadata field is set. - */ - @java.lang.Override - public boolean hasMetadata() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return The metadata. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - - public static final int GROUP_BY_FIELD_NUMBER = 22; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy groupBy_; - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return Whether the groupBy field is set. - */ - @java.lang.Override - public boolean hasGroupBy() { - return ((bitField0_ & 0x00000008) != 0); - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return The groupBy. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getGroupBy() { - return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder() { - return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; - } - - public static final int LIMIT_FIELD_NUMBER = 30; - private int limit_ = 0; - /** - *
-     * affects order and length of results. 0/empty (default value) means disabled
-     * 
- * - * uint32 limit = 30; - * @return The limit. - */ - @java.lang.Override - public int getLimit() { - return limit_; - } - - public static final int OFFSET_FIELD_NUMBER = 31; - private int offset_ = 0; - /** - * uint32 offset = 31; - * @return The offset. - */ - @java.lang.Override - public int getOffset() { - return offset_; - } - - public static final int AUTOCUT_FIELD_NUMBER = 32; - private int autocut_ = 0; - /** - * uint32 autocut = 32; - * @return The autocut. - */ - @java.lang.Override - public int getAutocut() { - return autocut_; - } - - public static final int AFTER_FIELD_NUMBER = 33; - @SuppressWarnings("serial") - private volatile java.lang.Object after_ = ""; - /** - * string after = 33; - * @return The after. - */ - @java.lang.Override - public java.lang.String getAfter() { - java.lang.Object ref = after_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - after_ = s; - return s; - } - } - /** - * string after = 33; - * @return The bytes for after. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getAfterBytes() { - java.lang.Object ref = after_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - after_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int SORT_BY_FIELD_NUMBER = 34; - @SuppressWarnings("serial") - private java.util.List sortBy_; - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - @java.lang.Override - public java.util.List getSortByList() { - return sortBy_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - @java.lang.Override - public java.util.List - getSortByOrBuilderList() { - return sortBy_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - @java.lang.Override - public int getSortByCount() { - return sortBy_.size(); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getSortBy(int index) { - return sortBy_.get(index); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( - int index) { - return sortBy_.get(index); - } - - public static final int FILTERS_FIELD_NUMBER = 40; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_; - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return Whether the filters field is set. - */ - @java.lang.Override - public boolean hasFilters() { - return ((bitField0_ & 0x00000010) != 0); - } - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return The filters. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; - } - /** - *
-     * matches/searches for objects
-     * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; - } - - public static final int HYBRID_SEARCH_FIELD_NUMBER = 41; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid hybridSearch_; - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return Whether the hybridSearch field is set. - */ - @java.lang.Override - public boolean hasHybridSearch() { - return ((bitField0_ & 0x00000020) != 0); - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return The hybridSearch. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybridSearch() { - return hybridSearch_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder() { - return hybridSearch_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; - } - - public static final int BM25_SEARCH_FIELD_NUMBER = 42; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 bm25Search_; - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return Whether the bm25Search field is set. - */ - @java.lang.Override - public boolean hasBm25Search() { - return ((bitField0_ & 0x00000040) != 0); - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return The bm25Search. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getBm25Search() { - return bm25Search_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder() { - return bm25Search_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; - } - - public static final int NEAR_VECTOR_FIELD_NUMBER = 43; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector nearVector_; - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return Whether the nearVector field is set. - */ - @java.lang.Override - public boolean hasNearVector() { - return ((bitField0_ & 0x00000080) != 0); - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return The nearVector. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() { - return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() { - return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; - } - - public static final int NEAR_OBJECT_FIELD_NUMBER = 44; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject nearObject_; - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return Whether the nearObject field is set. - */ - @java.lang.Override - public boolean hasNearObject() { - return ((bitField0_ & 0x00000100) != 0); - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return The nearObject. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject() { - return nearObject_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() { - return nearObject_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; - } - - public static final int NEAR_TEXT_FIELD_NUMBER = 45; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch nearText_; - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return Whether the nearText field is set. - */ - @java.lang.Override - public boolean hasNearText() { - return ((bitField0_ & 0x00000200) != 0); - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return The nearText. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() { - return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() { - return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; - } - - public static final int NEAR_IMAGE_FIELD_NUMBER = 46; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch nearImage_; - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return Whether the nearImage field is set. - */ - @java.lang.Override - public boolean hasNearImage() { - return ((bitField0_ & 0x00000400) != 0); - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return The nearImage. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage() { - return nearImage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() { - return nearImage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; - } - - public static final int NEAR_AUDIO_FIELD_NUMBER = 47; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch nearAudio_; - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return Whether the nearAudio field is set. - */ - @java.lang.Override - public boolean hasNearAudio() { - return ((bitField0_ & 0x00000800) != 0); - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return The nearAudio. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() { - return nearAudio_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() { - return nearAudio_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; - } - - public static final int NEAR_VIDEO_FIELD_NUMBER = 48; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch nearVideo_; - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return Whether the nearVideo field is set. - */ - @java.lang.Override - public boolean hasNearVideo() { - return ((bitField0_ & 0x00001000) != 0); - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return The nearVideo. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() { - return nearVideo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() { - return nearVideo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; - } - - public static final int NEAR_DEPTH_FIELD_NUMBER = 49; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch nearDepth_; - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return Whether the nearDepth field is set. - */ - @java.lang.Override - public boolean hasNearDepth() { - return ((bitField0_ & 0x00002000) != 0); - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return The nearDepth. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() { - return nearDepth_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() { - return nearDepth_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; - } - - public static final int NEAR_THERMAL_FIELD_NUMBER = 50; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch nearThermal_; - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return Whether the nearThermal field is set. - */ - @java.lang.Override - public boolean hasNearThermal() { - return ((bitField0_ & 0x00004000) != 0); - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return The nearThermal. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() { - return nearThermal_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() { - return nearThermal_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; - } - - public static final int NEAR_IMU_FIELD_NUMBER = 51; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch nearImu_; - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return Whether the nearImu field is set. - */ - @java.lang.Override - public boolean hasNearImu() { - return ((bitField0_ & 0x00008000) != 0); - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return The nearImu. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() { - return nearImu_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() { - return nearImu_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; - } - - public static final int GENERATIVE_FIELD_NUMBER = 60; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch generative_; - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return Whether the generative field is set. - */ - @java.lang.Override - public boolean hasGenerative() { - return ((bitField0_ & 0x00010000) != 0); - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return The generative. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getGenerative() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; - } - - public static final int RERANK_FIELD_NUMBER = 61; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank rerank_; - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return Whether the rerank field is set. - */ - @java.lang.Override - public boolean hasRerank() { - return ((bitField0_ & 0x00020000) != 0); - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return The rerank. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getRerank() { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder() { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; - } - - public static final int USES_123_API_FIELD_NUMBER = 100; - private boolean uses123Api_ = false; - /** - * bool uses_123_api = 100 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. - * See v1/search_get.proto;l=51 - * @return The uses123Api. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getUses123Api() { - return uses123Api_; - } - - public static final int USES_125_API_FIELD_NUMBER = 101; - private boolean uses125Api_ = false; - /** - * bool uses_125_api = 101 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. - * See v1/search_get.proto;l=52 - * @return The uses125Api. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getUses125Api() { - return uses125Api_; - } - - public static final int USES_127_API_FIELD_NUMBER = 102; - private boolean uses127Api_ = false; - /** - * bool uses_127_api = 102; - * @return The uses127Api. - */ - @java.lang.Override - public boolean getUses127Api() { - return uses127Api_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, collection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 10, tenant_); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeEnum(11, consistencyLevel_); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(20, getProperties()); - } - if (((bitField0_ & 0x00000004) != 0)) { - output.writeMessage(21, getMetadata()); - } - if (((bitField0_ & 0x00000008) != 0)) { - output.writeMessage(22, getGroupBy()); - } - if (limit_ != 0) { - output.writeUInt32(30, limit_); - } - if (offset_ != 0) { - output.writeUInt32(31, offset_); - } - if (autocut_ != 0) { - output.writeUInt32(32, autocut_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(after_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 33, after_); - } - for (int i = 0; i < sortBy_.size(); i++) { - output.writeMessage(34, sortBy_.get(i)); - } - if (((bitField0_ & 0x00000010) != 0)) { - output.writeMessage(40, getFilters()); - } - if (((bitField0_ & 0x00000020) != 0)) { - output.writeMessage(41, getHybridSearch()); - } - if (((bitField0_ & 0x00000040) != 0)) { - output.writeMessage(42, getBm25Search()); - } - if (((bitField0_ & 0x00000080) != 0)) { - output.writeMessage(43, getNearVector()); - } - if (((bitField0_ & 0x00000100) != 0)) { - output.writeMessage(44, getNearObject()); - } - if (((bitField0_ & 0x00000200) != 0)) { - output.writeMessage(45, getNearText()); - } - if (((bitField0_ & 0x00000400) != 0)) { - output.writeMessage(46, getNearImage()); - } - if (((bitField0_ & 0x00000800) != 0)) { - output.writeMessage(47, getNearAudio()); - } - if (((bitField0_ & 0x00001000) != 0)) { - output.writeMessage(48, getNearVideo()); - } - if (((bitField0_ & 0x00002000) != 0)) { - output.writeMessage(49, getNearDepth()); - } - if (((bitField0_ & 0x00004000) != 0)) { - output.writeMessage(50, getNearThermal()); - } - if (((bitField0_ & 0x00008000) != 0)) { - output.writeMessage(51, getNearImu()); - } - if (((bitField0_ & 0x00010000) != 0)) { - output.writeMessage(60, getGenerative()); - } - if (((bitField0_ & 0x00020000) != 0)) { - output.writeMessage(61, getRerank()); - } - if (uses123Api_ != false) { - output.writeBool(100, uses123Api_); - } - if (uses125Api_ != false) { - output.writeBool(101, uses125Api_); - } - if (uses127Api_ != false) { - output.writeBool(102, uses127Api_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, collection_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(10, tenant_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeEnumSize(11, consistencyLevel_); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(20, getProperties()); - } - if (((bitField0_ & 0x00000004) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(21, getMetadata()); - } - if (((bitField0_ & 0x00000008) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(22, getGroupBy()); - } - if (limit_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeUInt32Size(30, limit_); - } - if (offset_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeUInt32Size(31, offset_); - } - if (autocut_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeUInt32Size(32, autocut_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(after_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(33, after_); - } - for (int i = 0; i < sortBy_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(34, sortBy_.get(i)); - } - if (((bitField0_ & 0x00000010) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(40, getFilters()); - } - if (((bitField0_ & 0x00000020) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(41, getHybridSearch()); - } - if (((bitField0_ & 0x00000040) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(42, getBm25Search()); - } - if (((bitField0_ & 0x00000080) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(43, getNearVector()); - } - if (((bitField0_ & 0x00000100) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(44, getNearObject()); - } - if (((bitField0_ & 0x00000200) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(45, getNearText()); - } - if (((bitField0_ & 0x00000400) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(46, getNearImage()); - } - if (((bitField0_ & 0x00000800) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(47, getNearAudio()); - } - if (((bitField0_ & 0x00001000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(48, getNearVideo()); - } - if (((bitField0_ & 0x00002000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(49, getNearDepth()); - } - if (((bitField0_ & 0x00004000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(50, getNearThermal()); - } - if (((bitField0_ & 0x00008000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(51, getNearImu()); - } - if (((bitField0_ & 0x00010000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(60, getGenerative()); - } - if (((bitField0_ & 0x00020000) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(61, getRerank()); - } - if (uses123Api_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(100, uses123Api_); - } - if (uses125Api_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(101, uses125Api_); - } - if (uses127Api_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(102, uses127Api_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest) obj; - - if (!getCollection() - .equals(other.getCollection())) return false; - if (!getTenant() - .equals(other.getTenant())) return false; - if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false; - if (hasConsistencyLevel()) { - if (consistencyLevel_ != other.consistencyLevel_) return false; - } - if (hasProperties() != other.hasProperties()) return false; - if (hasProperties()) { - if (!getProperties() - .equals(other.getProperties())) return false; - } - if (hasMetadata() != other.hasMetadata()) return false; - if (hasMetadata()) { - if (!getMetadata() - .equals(other.getMetadata())) return false; - } - if (hasGroupBy() != other.hasGroupBy()) return false; - if (hasGroupBy()) { - if (!getGroupBy() - .equals(other.getGroupBy())) return false; - } - if (getLimit() - != other.getLimit()) return false; - if (getOffset() - != other.getOffset()) return false; - if (getAutocut() - != other.getAutocut()) return false; - if (!getAfter() - .equals(other.getAfter())) return false; - if (!getSortByList() - .equals(other.getSortByList())) return false; - if (hasFilters() != other.hasFilters()) return false; - if (hasFilters()) { - if (!getFilters() - .equals(other.getFilters())) return false; - } - if (hasHybridSearch() != other.hasHybridSearch()) return false; - if (hasHybridSearch()) { - if (!getHybridSearch() - .equals(other.getHybridSearch())) return false; - } - if (hasBm25Search() != other.hasBm25Search()) return false; - if (hasBm25Search()) { - if (!getBm25Search() - .equals(other.getBm25Search())) return false; - } - if (hasNearVector() != other.hasNearVector()) return false; - if (hasNearVector()) { - if (!getNearVector() - .equals(other.getNearVector())) return false; - } - if (hasNearObject() != other.hasNearObject()) return false; - if (hasNearObject()) { - if (!getNearObject() - .equals(other.getNearObject())) return false; - } - if (hasNearText() != other.hasNearText()) return false; - if (hasNearText()) { - if (!getNearText() - .equals(other.getNearText())) return false; - } - if (hasNearImage() != other.hasNearImage()) return false; - if (hasNearImage()) { - if (!getNearImage() - .equals(other.getNearImage())) return false; - } - if (hasNearAudio() != other.hasNearAudio()) return false; - if (hasNearAudio()) { - if (!getNearAudio() - .equals(other.getNearAudio())) return false; - } - if (hasNearVideo() != other.hasNearVideo()) return false; - if (hasNearVideo()) { - if (!getNearVideo() - .equals(other.getNearVideo())) return false; - } - if (hasNearDepth() != other.hasNearDepth()) return false; - if (hasNearDepth()) { - if (!getNearDepth() - .equals(other.getNearDepth())) return false; - } - if (hasNearThermal() != other.hasNearThermal()) return false; - if (hasNearThermal()) { - if (!getNearThermal() - .equals(other.getNearThermal())) return false; - } - if (hasNearImu() != other.hasNearImu()) return false; - if (hasNearImu()) { - if (!getNearImu() - .equals(other.getNearImu())) return false; - } - if (hasGenerative() != other.hasGenerative()) return false; - if (hasGenerative()) { - if (!getGenerative() - .equals(other.getGenerative())) return false; - } - if (hasRerank() != other.hasRerank()) return false; - if (hasRerank()) { - if (!getRerank() - .equals(other.getRerank())) return false; - } - if (getUses123Api() - != other.getUses123Api()) return false; - if (getUses125Api() - != other.getUses125Api()) return false; - if (getUses127Api() - != other.getUses127Api()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getCollection().hashCode(); - hash = (37 * hash) + TENANT_FIELD_NUMBER; - hash = (53 * hash) + getTenant().hashCode(); - if (hasConsistencyLevel()) { - hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER; - hash = (53 * hash) + consistencyLevel_; - } - if (hasProperties()) { - hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getProperties().hashCode(); - } - if (hasMetadata()) { - hash = (37 * hash) + METADATA_FIELD_NUMBER; - hash = (53 * hash) + getMetadata().hashCode(); - } - if (hasGroupBy()) { - hash = (37 * hash) + GROUP_BY_FIELD_NUMBER; - hash = (53 * hash) + getGroupBy().hashCode(); - } - hash = (37 * hash) + LIMIT_FIELD_NUMBER; - hash = (53 * hash) + getLimit(); - hash = (37 * hash) + OFFSET_FIELD_NUMBER; - hash = (53 * hash) + getOffset(); - hash = (37 * hash) + AUTOCUT_FIELD_NUMBER; - hash = (53 * hash) + getAutocut(); - hash = (37 * hash) + AFTER_FIELD_NUMBER; - hash = (53 * hash) + getAfter().hashCode(); - if (getSortByCount() > 0) { - hash = (37 * hash) + SORT_BY_FIELD_NUMBER; - hash = (53 * hash) + getSortByList().hashCode(); - } - if (hasFilters()) { - hash = (37 * hash) + FILTERS_FIELD_NUMBER; - hash = (53 * hash) + getFilters().hashCode(); - } - if (hasHybridSearch()) { - hash = (37 * hash) + HYBRID_SEARCH_FIELD_NUMBER; - hash = (53 * hash) + getHybridSearch().hashCode(); - } - if (hasBm25Search()) { - hash = (37 * hash) + BM25_SEARCH_FIELD_NUMBER; - hash = (53 * hash) + getBm25Search().hashCode(); - } - if (hasNearVector()) { - hash = (37 * hash) + NEAR_VECTOR_FIELD_NUMBER; - hash = (53 * hash) + getNearVector().hashCode(); - } - if (hasNearObject()) { - hash = (37 * hash) + NEAR_OBJECT_FIELD_NUMBER; - hash = (53 * hash) + getNearObject().hashCode(); - } - if (hasNearText()) { - hash = (37 * hash) + NEAR_TEXT_FIELD_NUMBER; - hash = (53 * hash) + getNearText().hashCode(); - } - if (hasNearImage()) { - hash = (37 * hash) + NEAR_IMAGE_FIELD_NUMBER; - hash = (53 * hash) + getNearImage().hashCode(); - } - if (hasNearAudio()) { - hash = (37 * hash) + NEAR_AUDIO_FIELD_NUMBER; - hash = (53 * hash) + getNearAudio().hashCode(); - } - if (hasNearVideo()) { - hash = (37 * hash) + NEAR_VIDEO_FIELD_NUMBER; - hash = (53 * hash) + getNearVideo().hashCode(); - } - if (hasNearDepth()) { - hash = (37 * hash) + NEAR_DEPTH_FIELD_NUMBER; - hash = (53 * hash) + getNearDepth().hashCode(); - } - if (hasNearThermal()) { - hash = (37 * hash) + NEAR_THERMAL_FIELD_NUMBER; - hash = (53 * hash) + getNearThermal().hashCode(); - } - if (hasNearImu()) { - hash = (37 * hash) + NEAR_IMU_FIELD_NUMBER; - hash = (53 * hash) + getNearImu().hashCode(); - } - if (hasGenerative()) { - hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; - hash = (53 * hash) + getGenerative().hashCode(); - } - if (hasRerank()) { - hash = (37 * hash) + RERANK_FIELD_NUMBER; - hash = (53 * hash) + getRerank().hashCode(); - } - hash = (37 * hash) + USES_123_API_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getUses123Api()); - hash = (37 * hash) + USES_125_API_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getUses125Api()); - hash = (37 * hash) + USES_127_API_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getUses127Api()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.SearchRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getPropertiesFieldBuilder(); - getMetadataFieldBuilder(); - getGroupByFieldBuilder(); - getSortByFieldBuilder(); - getFiltersFieldBuilder(); - getHybridSearchFieldBuilder(); - getBm25SearchFieldBuilder(); - getNearVectorFieldBuilder(); - getNearObjectFieldBuilder(); - getNearTextFieldBuilder(); - getNearImageFieldBuilder(); - getNearAudioFieldBuilder(); - getNearVideoFieldBuilder(); - getNearDepthFieldBuilder(); - getNearThermalFieldBuilder(); - getNearImuFieldBuilder(); - getGenerativeFieldBuilder(); - getRerankFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - collection_ = ""; - tenant_ = ""; - consistencyLevel_ = 0; - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - groupBy_ = null; - if (groupByBuilder_ != null) { - groupByBuilder_.dispose(); - groupByBuilder_ = null; - } - limit_ = 0; - offset_ = 0; - autocut_ = 0; - after_ = ""; - if (sortByBuilder_ == null) { - sortBy_ = java.util.Collections.emptyList(); - } else { - sortBy_ = null; - sortByBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000400); - filters_ = null; - if (filtersBuilder_ != null) { - filtersBuilder_.dispose(); - filtersBuilder_ = null; - } - hybridSearch_ = null; - if (hybridSearchBuilder_ != null) { - hybridSearchBuilder_.dispose(); - hybridSearchBuilder_ = null; - } - bm25Search_ = null; - if (bm25SearchBuilder_ != null) { - bm25SearchBuilder_.dispose(); - bm25SearchBuilder_ = null; - } - nearVector_ = null; - if (nearVectorBuilder_ != null) { - nearVectorBuilder_.dispose(); - nearVectorBuilder_ = null; - } - nearObject_ = null; - if (nearObjectBuilder_ != null) { - nearObjectBuilder_.dispose(); - nearObjectBuilder_ = null; - } - nearText_ = null; - if (nearTextBuilder_ != null) { - nearTextBuilder_.dispose(); - nearTextBuilder_ = null; - } - nearImage_ = null; - if (nearImageBuilder_ != null) { - nearImageBuilder_.dispose(); - nearImageBuilder_ = null; - } - nearAudio_ = null; - if (nearAudioBuilder_ != null) { - nearAudioBuilder_.dispose(); - nearAudioBuilder_ = null; - } - nearVideo_ = null; - if (nearVideoBuilder_ != null) { - nearVideoBuilder_.dispose(); - nearVideoBuilder_ = null; - } - nearDepth_ = null; - if (nearDepthBuilder_ != null) { - nearDepthBuilder_.dispose(); - nearDepthBuilder_ = null; - } - nearThermal_ = null; - if (nearThermalBuilder_ != null) { - nearThermalBuilder_.dispose(); - nearThermalBuilder_ = null; - } - nearImu_ = null; - if (nearImuBuilder_ != null) { - nearImuBuilder_.dispose(); - nearImuBuilder_ = null; - } - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - rerank_ = null; - if (rerankBuilder_ != null) { - rerankBuilder_.dispose(); - rerankBuilder_ = null; - } - uses123Api_ = false; - uses125Api_ = false; - uses127Api_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest result) { - if (sortByBuilder_ == null) { - if (((bitField0_ & 0x00000400) != 0)) { - sortBy_ = java.util.Collections.unmodifiableList(sortBy_); - bitField0_ = (bitField0_ & ~0x00000400); - } - result.sortBy_ = sortBy_; - } else { - result.sortBy_ = sortByBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.collection_ = collection_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.tenant_ = tenant_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000004) != 0)) { - result.consistencyLevel_ = consistencyLevel_; - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.properties_ = propertiesBuilder_ == null - ? properties_ - : propertiesBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.metadata_ = metadataBuilder_ == null - ? metadata_ - : metadataBuilder_.build(); - to_bitField0_ |= 0x00000004; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.groupBy_ = groupByBuilder_ == null - ? groupBy_ - : groupByBuilder_.build(); - to_bitField0_ |= 0x00000008; - } - if (((from_bitField0_ & 0x00000040) != 0)) { - result.limit_ = limit_; - } - if (((from_bitField0_ & 0x00000080) != 0)) { - result.offset_ = offset_; - } - if (((from_bitField0_ & 0x00000100) != 0)) { - result.autocut_ = autocut_; - } - if (((from_bitField0_ & 0x00000200) != 0)) { - result.after_ = after_; - } - if (((from_bitField0_ & 0x00000800) != 0)) { - result.filters_ = filtersBuilder_ == null - ? filters_ - : filtersBuilder_.build(); - to_bitField0_ |= 0x00000010; - } - if (((from_bitField0_ & 0x00001000) != 0)) { - result.hybridSearch_ = hybridSearchBuilder_ == null - ? hybridSearch_ - : hybridSearchBuilder_.build(); - to_bitField0_ |= 0x00000020; - } - if (((from_bitField0_ & 0x00002000) != 0)) { - result.bm25Search_ = bm25SearchBuilder_ == null - ? bm25Search_ - : bm25SearchBuilder_.build(); - to_bitField0_ |= 0x00000040; - } - if (((from_bitField0_ & 0x00004000) != 0)) { - result.nearVector_ = nearVectorBuilder_ == null - ? nearVector_ - : nearVectorBuilder_.build(); - to_bitField0_ |= 0x00000080; - } - if (((from_bitField0_ & 0x00008000) != 0)) { - result.nearObject_ = nearObjectBuilder_ == null - ? nearObject_ - : nearObjectBuilder_.build(); - to_bitField0_ |= 0x00000100; - } - if (((from_bitField0_ & 0x00010000) != 0)) { - result.nearText_ = nearTextBuilder_ == null - ? nearText_ - : nearTextBuilder_.build(); - to_bitField0_ |= 0x00000200; - } - if (((from_bitField0_ & 0x00020000) != 0)) { - result.nearImage_ = nearImageBuilder_ == null - ? nearImage_ - : nearImageBuilder_.build(); - to_bitField0_ |= 0x00000400; - } - if (((from_bitField0_ & 0x00040000) != 0)) { - result.nearAudio_ = nearAudioBuilder_ == null - ? nearAudio_ - : nearAudioBuilder_.build(); - to_bitField0_ |= 0x00000800; - } - if (((from_bitField0_ & 0x00080000) != 0)) { - result.nearVideo_ = nearVideoBuilder_ == null - ? nearVideo_ - : nearVideoBuilder_.build(); - to_bitField0_ |= 0x00001000; - } - if (((from_bitField0_ & 0x00100000) != 0)) { - result.nearDepth_ = nearDepthBuilder_ == null - ? nearDepth_ - : nearDepthBuilder_.build(); - to_bitField0_ |= 0x00002000; - } - if (((from_bitField0_ & 0x00200000) != 0)) { - result.nearThermal_ = nearThermalBuilder_ == null - ? nearThermal_ - : nearThermalBuilder_.build(); - to_bitField0_ |= 0x00004000; - } - if (((from_bitField0_ & 0x00400000) != 0)) { - result.nearImu_ = nearImuBuilder_ == null - ? nearImu_ - : nearImuBuilder_.build(); - to_bitField0_ |= 0x00008000; - } - if (((from_bitField0_ & 0x00800000) != 0)) { - result.generative_ = generativeBuilder_ == null - ? generative_ - : generativeBuilder_.build(); - to_bitField0_ |= 0x00010000; - } - if (((from_bitField0_ & 0x01000000) != 0)) { - result.rerank_ = rerankBuilder_ == null - ? rerank_ - : rerankBuilder_.build(); - to_bitField0_ |= 0x00020000; - } - if (((from_bitField0_ & 0x02000000) != 0)) { - result.uses123Api_ = uses123Api_; - } - if (((from_bitField0_ & 0x04000000) != 0)) { - result.uses125Api_ = uses125Api_; - } - if (((from_bitField0_ & 0x08000000) != 0)) { - result.uses127Api_ = uses127Api_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance()) return this; - if (!other.getCollection().isEmpty()) { - collection_ = other.collection_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.getTenant().isEmpty()) { - tenant_ = other.tenant_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (other.hasConsistencyLevel()) { - setConsistencyLevel(other.getConsistencyLevel()); - } - if (other.hasProperties()) { - mergeProperties(other.getProperties()); - } - if (other.hasMetadata()) { - mergeMetadata(other.getMetadata()); - } - if (other.hasGroupBy()) { - mergeGroupBy(other.getGroupBy()); - } - if (other.getLimit() != 0) { - setLimit(other.getLimit()); - } - if (other.getOffset() != 0) { - setOffset(other.getOffset()); - } - if (other.getAutocut() != 0) { - setAutocut(other.getAutocut()); - } - if (!other.getAfter().isEmpty()) { - after_ = other.after_; - bitField0_ |= 0x00000200; - onChanged(); - } - if (sortByBuilder_ == null) { - if (!other.sortBy_.isEmpty()) { - if (sortBy_.isEmpty()) { - sortBy_ = other.sortBy_; - bitField0_ = (bitField0_ & ~0x00000400); - } else { - ensureSortByIsMutable(); - sortBy_.addAll(other.sortBy_); - } - onChanged(); - } - } else { - if (!other.sortBy_.isEmpty()) { - if (sortByBuilder_.isEmpty()) { - sortByBuilder_.dispose(); - sortByBuilder_ = null; - sortBy_ = other.sortBy_; - bitField0_ = (bitField0_ & ~0x00000400); - sortByBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getSortByFieldBuilder() : null; - } else { - sortByBuilder_.addAllMessages(other.sortBy_); - } - } - } - if (other.hasFilters()) { - mergeFilters(other.getFilters()); - } - if (other.hasHybridSearch()) { - mergeHybridSearch(other.getHybridSearch()); - } - if (other.hasBm25Search()) { - mergeBm25Search(other.getBm25Search()); - } - if (other.hasNearVector()) { - mergeNearVector(other.getNearVector()); - } - if (other.hasNearObject()) { - mergeNearObject(other.getNearObject()); - } - if (other.hasNearText()) { - mergeNearText(other.getNearText()); - } - if (other.hasNearImage()) { - mergeNearImage(other.getNearImage()); - } - if (other.hasNearAudio()) { - mergeNearAudio(other.getNearAudio()); - } - if (other.hasNearVideo()) { - mergeNearVideo(other.getNearVideo()); - } - if (other.hasNearDepth()) { - mergeNearDepth(other.getNearDepth()); - } - if (other.hasNearThermal()) { - mergeNearThermal(other.getNearThermal()); - } - if (other.hasNearImu()) { - mergeNearImu(other.getNearImu()); - } - if (other.hasGenerative()) { - mergeGenerative(other.getGenerative()); - } - if (other.hasRerank()) { - mergeRerank(other.getRerank()); - } - if (other.getUses123Api() != false) { - setUses123Api(other.getUses123Api()); - } - if (other.getUses125Api() != false) { - setUses125Api(other.getUses125Api()); - } - if (other.getUses127Api() != false) { - setUses127Api(other.getUses127Api()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - collection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 82: { - tenant_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 82 - case 88: { - consistencyLevel_ = input.readEnum(); - bitField0_ |= 0x00000004; - break; - } // case 88 - case 162: { - input.readMessage( - getPropertiesFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000008; - break; - } // case 162 - case 170: { - input.readMessage( - getMetadataFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000010; - break; - } // case 170 - case 178: { - input.readMessage( - getGroupByFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000020; - break; - } // case 178 - case 240: { - limit_ = input.readUInt32(); - bitField0_ |= 0x00000040; - break; - } // case 240 - case 248: { - offset_ = input.readUInt32(); - bitField0_ |= 0x00000080; - break; - } // case 248 - case 256: { - autocut_ = input.readUInt32(); - bitField0_ |= 0x00000100; - break; - } // case 256 - case 266: { - after_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000200; - break; - } // case 266 - case 274: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.parser(), - extensionRegistry); - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - sortBy_.add(m); - } else { - sortByBuilder_.addMessage(m); - } - break; - } // case 274 - case 322: { - input.readMessage( - getFiltersFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000800; - break; - } // case 322 - case 330: { - input.readMessage( - getHybridSearchFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00001000; - break; - } // case 330 - case 338: { - input.readMessage( - getBm25SearchFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00002000; - break; - } // case 338 - case 346: { - input.readMessage( - getNearVectorFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00004000; - break; - } // case 346 - case 354: { - input.readMessage( - getNearObjectFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00008000; - break; - } // case 354 - case 362: { - input.readMessage( - getNearTextFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00010000; - break; - } // case 362 - case 370: { - input.readMessage( - getNearImageFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00020000; - break; - } // case 370 - case 378: { - input.readMessage( - getNearAudioFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00040000; - break; - } // case 378 - case 386: { - input.readMessage( - getNearVideoFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00080000; - break; - } // case 386 - case 394: { - input.readMessage( - getNearDepthFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00100000; - break; - } // case 394 - case 402: { - input.readMessage( - getNearThermalFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00200000; - break; - } // case 402 - case 410: { - input.readMessage( - getNearImuFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00400000; - break; - } // case 410 - case 482: { - input.readMessage( - getGenerativeFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00800000; - break; - } // case 482 - case 490: { - input.readMessage( - getRerankFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x01000000; - break; - } // case 490 - case 800: { - uses123Api_ = input.readBool(); - bitField0_ |= 0x02000000; - break; - } // case 800 - case 808: { - uses125Api_ = input.readBool(); - bitField0_ |= 0x04000000; - break; - } // case 808 - case 816: { - uses127Api_ = input.readBool(); - bitField0_ |= 0x08000000; - break; - } // case 816 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object collection_ = ""; - /** - *
-       *required
-       * 
- * - * string collection = 1; - * @return The collection. - */ - public java.lang.String getCollection() { - java.lang.Object ref = collection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - collection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - *
-       *required
-       * 
- * - * string collection = 1; - * @return The bytes for collection. - */ - public com.google.protobuf.ByteString - getCollectionBytes() { - java.lang.Object ref = collection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - collection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - *
-       *required
-       * 
- * - * string collection = 1; - * @param value The collection to set. - * @return This builder for chaining. - */ - public Builder setCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - collection_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       *required
-       * 
- * - * string collection = 1; - * @return This builder for chaining. - */ - public Builder clearCollection() { - collection_ = getDefaultInstance().getCollection(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - *
-       *required
-       * 
- * - * string collection = 1; - * @param value The bytes for collection to set. - * @return This builder for chaining. - */ - public Builder setCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - collection_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object tenant_ = ""; - /** - *
-       * parameters
-       * 
- * - * string tenant = 10; - * @return The tenant. - */ - public java.lang.String getTenant() { - java.lang.Object ref = tenant_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - tenant_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - *
-       * parameters
-       * 
- * - * string tenant = 10; - * @return The bytes for tenant. - */ - public com.google.protobuf.ByteString - getTenantBytes() { - java.lang.Object ref = tenant_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - tenant_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - *
-       * parameters
-       * 
- * - * string tenant = 10; - * @param value The tenant to set. - * @return This builder for chaining. - */ - public Builder setTenant( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - tenant_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * parameters
-       * 
- * - * string tenant = 10; - * @return This builder for chaining. - */ - public Builder clearTenant() { - tenant_ = getDefaultInstance().getTenant(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - *
-       * parameters
-       * 
- * - * string tenant = 10; - * @param value The bytes for tenant to set. - * @return This builder for chaining. - */ - public Builder setTenantBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - tenant_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private int consistencyLevel_ = 0; - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return Whether the consistencyLevel field is set. - */ - @java.lang.Override public boolean hasConsistencyLevel() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The enum numeric value on the wire for consistencyLevel. - */ - @java.lang.Override public int getConsistencyLevelValue() { - return consistencyLevel_; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @param value The enum numeric value on the wire for consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevelValue(int value) { - consistencyLevel_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return The consistencyLevel. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @param value The consistencyLevel to set. - * @return This builder for chaining. - */ - public Builder setConsistencyLevel(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel value) { - if (value == null) { - throw new NullPointerException(); - } - bitField0_ |= 0x00000004; - consistencyLevel_ = value.getNumber(); - onChanged(); - return this; - } - /** - * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; - * @return This builder for chaining. - */ - public Builder clearConsistencyLevel() { - bitField0_ = (bitField0_ & ~0x00000004); - consistencyLevel_ = 0; - onChanged(); - return this; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest properties_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> propertiesBuilder_; - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return Whether the properties field is set. - */ - public boolean hasProperties() { - return ((bitField0_ & 0x00000008) != 0); - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - * @return The properties. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties() { - if (propertiesBuilder_ == null) { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } else { - return propertiesBuilder_.getMessage(); - } - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - properties_ = value; - } else { - propertiesBuilder_.setMessage(value); - } - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public Builder setProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder builderForValue) { - if (propertiesBuilder_ == null) { - properties_ = builderForValue.build(); - } else { - propertiesBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public Builder mergeProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest value) { - if (propertiesBuilder_ == null) { - if (((bitField0_ & 0x00000008) != 0) && - properties_ != null && - properties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) { - getPropertiesBuilder().mergeFrom(value); - } else { - properties_ = value; - } - } else { - propertiesBuilder_.mergeFrom(value); - } - if (properties_ != null) { - bitField0_ |= 0x00000008; - onChanged(); - } - return this; - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public Builder clearProperties() { - bitField0_ = (bitField0_ & ~0x00000008); - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - onChanged(); - return this; - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder getPropertiesBuilder() { - bitField0_ |= 0x00000008; - onChanged(); - return getPropertiesFieldBuilder().getBuilder(); - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { - if (propertiesBuilder_ != null) { - return propertiesBuilder_.getMessageOrBuilder(); - } else { - return properties_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - } - /** - *
-       * what is returned
-       * 
- * - * optional .weaviate.v1.PropertiesRequest properties = 20; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> - getPropertiesFieldBuilder() { - if (propertiesBuilder_ == null) { - propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder>( - getProperties(), - getParentForChildren(), - isClean()); - properties_ = null; - } - return propertiesBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest metadata_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder> metadataBuilder_; - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return Whether the metadata field is set. - */ - public boolean hasMetadata() { - return ((bitField0_ & 0x00000010) != 0); - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - * @return The metadata. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata() { - if (metadataBuilder_ == null) { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } else { - return metadataBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest value) { - if (metadataBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - metadata_ = value; - } else { - metadataBuilder_.setMessage(value); - } - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public Builder setMetadata( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder builderForValue) { - if (metadataBuilder_ == null) { - metadata_ = builderForValue.build(); - } else { - metadataBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest value) { - if (metadataBuilder_ == null) { - if (((bitField0_ & 0x00000010) != 0) && - metadata_ != null && - metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) { - getMetadataBuilder().mergeFrom(value); - } else { - metadata_ = value; - } - } else { - metadataBuilder_.mergeFrom(value); - } - if (metadata_ != null) { - bitField0_ |= 0x00000010; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public Builder clearMetadata() { - bitField0_ = (bitField0_ & ~0x00000010); - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder getMetadataBuilder() { - bitField0_ |= 0x00000010; - onChanged(); - return getMetadataFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { - if (metadataBuilder_ != null) { - return metadataBuilder_.getMessageOrBuilder(); - } else { - return metadata_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - } - /** - * optional .weaviate.v1.MetadataRequest metadata = 21; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder> - getMetadataFieldBuilder() { - if (metadataBuilder_ == null) { - metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder>( - getMetadata(), - getParentForChildren(), - isClean()); - metadata_ = null; - } - return metadataBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy groupBy_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder> groupByBuilder_; - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return Whether the groupBy field is set. - */ - public boolean hasGroupBy() { - return ((bitField0_ & 0x00000020) != 0); - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - * @return The groupBy. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getGroupBy() { - if (groupByBuilder_ == null) { - return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; - } else { - return groupByBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public Builder setGroupBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy value) { - if (groupByBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - groupBy_ = value; - } else { - groupByBuilder_.setMessage(value); - } - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public Builder setGroupBy( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder builderForValue) { - if (groupByBuilder_ == null) { - groupBy_ = builderForValue.build(); - } else { - groupByBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public Builder mergeGroupBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy value) { - if (groupByBuilder_ == null) { - if (((bitField0_ & 0x00000020) != 0) && - groupBy_ != null && - groupBy_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance()) { - getGroupByBuilder().mergeFrom(value); - } else { - groupBy_ = value; - } - } else { - groupByBuilder_.mergeFrom(value); - } - if (groupBy_ != null) { - bitField0_ |= 0x00000020; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public Builder clearGroupBy() { - bitField0_ = (bitField0_ & ~0x00000020); - groupBy_ = null; - if (groupByBuilder_ != null) { - groupByBuilder_.dispose(); - groupByBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder getGroupByBuilder() { - bitField0_ |= 0x00000020; - onChanged(); - return getGroupByFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder() { - if (groupByBuilder_ != null) { - return groupByBuilder_.getMessageOrBuilder(); - } else { - return groupBy_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; - } - } - /** - * optional .weaviate.v1.GroupBy group_by = 22; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder> - getGroupByFieldBuilder() { - if (groupByBuilder_ == null) { - groupByBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder>( - getGroupBy(), - getParentForChildren(), - isClean()); - groupBy_ = null; - } - return groupByBuilder_; - } - - private int limit_ ; - /** - *
-       * affects order and length of results. 0/empty (default value) means disabled
-       * 
- * - * uint32 limit = 30; - * @return The limit. - */ - @java.lang.Override - public int getLimit() { - return limit_; - } - /** - *
-       * affects order and length of results. 0/empty (default value) means disabled
-       * 
- * - * uint32 limit = 30; - * @param value The limit to set. - * @return This builder for chaining. - */ - public Builder setLimit(int value) { - - limit_ = value; - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - *
-       * affects order and length of results. 0/empty (default value) means disabled
-       * 
- * - * uint32 limit = 30; - * @return This builder for chaining. - */ - public Builder clearLimit() { - bitField0_ = (bitField0_ & ~0x00000040); - limit_ = 0; - onChanged(); - return this; - } - - private int offset_ ; - /** - * uint32 offset = 31; - * @return The offset. - */ - @java.lang.Override - public int getOffset() { - return offset_; - } - /** - * uint32 offset = 31; - * @param value The offset to set. - * @return This builder for chaining. - */ - public Builder setOffset(int value) { - - offset_ = value; - bitField0_ |= 0x00000080; - onChanged(); - return this; - } - /** - * uint32 offset = 31; - * @return This builder for chaining. - */ - public Builder clearOffset() { - bitField0_ = (bitField0_ & ~0x00000080); - offset_ = 0; - onChanged(); - return this; - } - - private int autocut_ ; - /** - * uint32 autocut = 32; - * @return The autocut. - */ - @java.lang.Override - public int getAutocut() { - return autocut_; - } - /** - * uint32 autocut = 32; - * @param value The autocut to set. - * @return This builder for chaining. - */ - public Builder setAutocut(int value) { - - autocut_ = value; - bitField0_ |= 0x00000100; - onChanged(); - return this; - } - /** - * uint32 autocut = 32; - * @return This builder for chaining. - */ - public Builder clearAutocut() { - bitField0_ = (bitField0_ & ~0x00000100); - autocut_ = 0; - onChanged(); - return this; - } - - private java.lang.Object after_ = ""; - /** - * string after = 33; - * @return The after. - */ - public java.lang.String getAfter() { - java.lang.Object ref = after_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - after_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string after = 33; - * @return The bytes for after. - */ - public com.google.protobuf.ByteString - getAfterBytes() { - java.lang.Object ref = after_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - after_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string after = 33; - * @param value The after to set. - * @return This builder for chaining. - */ - public Builder setAfter( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - after_ = value; - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - * string after = 33; - * @return This builder for chaining. - */ - public Builder clearAfter() { - after_ = getDefaultInstance().getAfter(); - bitField0_ = (bitField0_ & ~0x00000200); - onChanged(); - return this; - } - /** - * string after = 33; - * @param value The bytes for after to set. - * @return This builder for chaining. - */ - public Builder setAfterBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - after_ = value; - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - - private java.util.List sortBy_ = - java.util.Collections.emptyList(); - private void ensureSortByIsMutable() { - if (!((bitField0_ & 0x00000400) != 0)) { - sortBy_ = new java.util.ArrayList(sortBy_); - bitField0_ |= 0x00000400; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder> sortByBuilder_; - - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public java.util.List getSortByList() { - if (sortByBuilder_ == null) { - return java.util.Collections.unmodifiableList(sortBy_); - } else { - return sortByBuilder_.getMessageList(); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public int getSortByCount() { - if (sortByBuilder_ == null) { - return sortBy_.size(); - } else { - return sortByBuilder_.getCount(); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getSortBy(int index) { - if (sortByBuilder_ == null) { - return sortBy_.get(index); - } else { - return sortByBuilder_.getMessage(index); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder setSortBy( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy value) { - if (sortByBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSortByIsMutable(); - sortBy_.set(index, value); - onChanged(); - } else { - sortByBuilder_.setMessage(index, value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder setSortBy( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - sortBy_.set(index, builderForValue.build()); - onChanged(); - } else { - sortByBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder addSortBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy value) { - if (sortByBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSortByIsMutable(); - sortBy_.add(value); - onChanged(); - } else { - sortByBuilder_.addMessage(value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder addSortBy( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy value) { - if (sortByBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureSortByIsMutable(); - sortBy_.add(index, value); - onChanged(); - } else { - sortByBuilder_.addMessage(index, value); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder addSortBy( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - sortBy_.add(builderForValue.build()); - onChanged(); - } else { - sortByBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder addSortBy( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - sortBy_.add(index, builderForValue.build()); - onChanged(); - } else { - sortByBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder addAllSortBy( - java.lang.Iterable values) { - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, sortBy_); - onChanged(); - } else { - sortByBuilder_.addAllMessages(values); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder clearSortBy() { - if (sortByBuilder_ == null) { - sortBy_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000400); - onChanged(); - } else { - sortByBuilder_.clear(); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public Builder removeSortBy(int index) { - if (sortByBuilder_ == null) { - ensureSortByIsMutable(); - sortBy_.remove(index); - onChanged(); - } else { - sortByBuilder_.remove(index); - } - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder getSortByBuilder( - int index) { - return getSortByFieldBuilder().getBuilder(index); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( - int index) { - if (sortByBuilder_ == null) { - return sortBy_.get(index); } else { - return sortByBuilder_.getMessageOrBuilder(index); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public java.util.List - getSortByOrBuilderList() { - if (sortByBuilder_ != null) { - return sortByBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(sortBy_); - } - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder addSortByBuilder() { - return getSortByFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.getDefaultInstance()); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder addSortByBuilder( - int index) { - return getSortByFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.getDefaultInstance()); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated .weaviate.v1.SortBy sort_by = 34; - */ - public java.util.List - getSortByBuilderList() { - return getSortByFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder> - getSortByFieldBuilder() { - if (sortByBuilder_ == null) { - sortByBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder>( - sortBy_, - ((bitField0_ & 0x00000400) != 0), - getParentForChildren(), - isClean()); - sortBy_ = null; - } - return sortByBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_; - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return Whether the filters field is set. - */ - public boolean hasFilters() { - return ((bitField0_ & 0x00000800) != 0); - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - * @return The filters. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() { - if (filtersBuilder_ == null) { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; - } else { - return filtersBuilder_.getMessage(); - } - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public Builder setFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) { - if (filtersBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - filters_ = value; - } else { - filtersBuilder_.setMessage(value); - } - bitField0_ |= 0x00000800; - onChanged(); - return this; - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public Builder setFilters( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) { - if (filtersBuilder_ == null) { - filters_ = builderForValue.build(); - } else { - filtersBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000800; - onChanged(); - return this; - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public Builder mergeFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) { - if (filtersBuilder_ == null) { - if (((bitField0_ & 0x00000800) != 0) && - filters_ != null && - filters_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance()) { - getFiltersBuilder().mergeFrom(value); - } else { - filters_ = value; - } - } else { - filtersBuilder_.mergeFrom(value); - } - if (filters_ != null) { - bitField0_ |= 0x00000800; - onChanged(); - } - return this; - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public Builder clearFilters() { - bitField0_ = (bitField0_ & ~0x00000800); - filters_ = null; - if (filtersBuilder_ != null) { - filtersBuilder_.dispose(); - filtersBuilder_ = null; - } - onChanged(); - return this; - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder getFiltersBuilder() { - bitField0_ |= 0x00000800; - onChanged(); - return getFiltersFieldBuilder().getBuilder(); - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { - if (filtersBuilder_ != null) { - return filtersBuilder_.getMessageOrBuilder(); - } else { - return filters_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; - } - } - /** - *
-       * matches/searches for objects
-       * 
- * - * optional .weaviate.v1.Filters filters = 40; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> - getFiltersFieldBuilder() { - if (filtersBuilder_ == null) { - filtersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder>( - getFilters(), - getParentForChildren(), - isClean()); - filters_ = null; - } - return filtersBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid hybridSearch_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder> hybridSearchBuilder_; - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return Whether the hybridSearch field is set. - */ - public boolean hasHybridSearch() { - return ((bitField0_ & 0x00001000) != 0); - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - * @return The hybridSearch. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybridSearch() { - if (hybridSearchBuilder_ == null) { - return hybridSearch_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; - } else { - return hybridSearchBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public Builder setHybridSearch(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid value) { - if (hybridSearchBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - hybridSearch_ = value; - } else { - hybridSearchBuilder_.setMessage(value); - } - bitField0_ |= 0x00001000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public Builder setHybridSearch( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder builderForValue) { - if (hybridSearchBuilder_ == null) { - hybridSearch_ = builderForValue.build(); - } else { - hybridSearchBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00001000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public Builder mergeHybridSearch(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid value) { - if (hybridSearchBuilder_ == null) { - if (((bitField0_ & 0x00001000) != 0) && - hybridSearch_ != null && - hybridSearch_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) { - getHybridSearchBuilder().mergeFrom(value); - } else { - hybridSearch_ = value; - } - } else { - hybridSearchBuilder_.mergeFrom(value); - } - if (hybridSearch_ != null) { - bitField0_ |= 0x00001000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public Builder clearHybridSearch() { - bitField0_ = (bitField0_ & ~0x00001000); - hybridSearch_ = null; - if (hybridSearchBuilder_ != null) { - hybridSearchBuilder_.dispose(); - hybridSearchBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder getHybridSearchBuilder() { - bitField0_ |= 0x00001000; - onChanged(); - return getHybridSearchFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder() { - if (hybridSearchBuilder_ != null) { - return hybridSearchBuilder_.getMessageOrBuilder(); - } else { - return hybridSearch_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; - } - } - /** - * optional .weaviate.v1.Hybrid hybrid_search = 41; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder> - getHybridSearchFieldBuilder() { - if (hybridSearchBuilder_ == null) { - hybridSearchBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder>( - getHybridSearch(), - getParentForChildren(), - isClean()); - hybridSearch_ = null; - } - return hybridSearchBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 bm25Search_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder> bm25SearchBuilder_; - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return Whether the bm25Search field is set. - */ - public boolean hasBm25Search() { - return ((bitField0_ & 0x00002000) != 0); - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - * @return The bm25Search. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getBm25Search() { - if (bm25SearchBuilder_ == null) { - return bm25Search_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; - } else { - return bm25SearchBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public Builder setBm25Search(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 value) { - if (bm25SearchBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - bm25Search_ = value; - } else { - bm25SearchBuilder_.setMessage(value); - } - bitField0_ |= 0x00002000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public Builder setBm25Search( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder builderForValue) { - if (bm25SearchBuilder_ == null) { - bm25Search_ = builderForValue.build(); - } else { - bm25SearchBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00002000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public Builder mergeBm25Search(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 value) { - if (bm25SearchBuilder_ == null) { - if (((bitField0_ & 0x00002000) != 0) && - bm25Search_ != null && - bm25Search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance()) { - getBm25SearchBuilder().mergeFrom(value); - } else { - bm25Search_ = value; - } - } else { - bm25SearchBuilder_.mergeFrom(value); - } - if (bm25Search_ != null) { - bitField0_ |= 0x00002000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public Builder clearBm25Search() { - bitField0_ = (bitField0_ & ~0x00002000); - bm25Search_ = null; - if (bm25SearchBuilder_ != null) { - bm25SearchBuilder_.dispose(); - bm25SearchBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder getBm25SearchBuilder() { - bitField0_ |= 0x00002000; - onChanged(); - return getBm25SearchFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder() { - if (bm25SearchBuilder_ != null) { - return bm25SearchBuilder_.getMessageOrBuilder(); - } else { - return bm25Search_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; - } - } - /** - * optional .weaviate.v1.BM25 bm25_search = 42; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder> - getBm25SearchFieldBuilder() { - if (bm25SearchBuilder_ == null) { - bm25SearchBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder>( - getBm25Search(), - getParentForChildren(), - isClean()); - bm25Search_ = null; - } - return bm25SearchBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector nearVector_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_; - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return Whether the nearVector field is set. - */ - public boolean hasNearVector() { - return ((bitField0_ & 0x00004000) != 0); - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - * @return The nearVector. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() { - if (nearVectorBuilder_ == null) { - return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; - } else { - return nearVectorBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public Builder setNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) { - if (nearVectorBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearVector_ = value; - } else { - nearVectorBuilder_.setMessage(value); - } - bitField0_ |= 0x00004000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public Builder setNearVector( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) { - if (nearVectorBuilder_ == null) { - nearVector_ = builderForValue.build(); - } else { - nearVectorBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00004000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public Builder mergeNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) { - if (nearVectorBuilder_ == null) { - if (((bitField0_ & 0x00004000) != 0) && - nearVector_ != null && - nearVector_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) { - getNearVectorBuilder().mergeFrom(value); - } else { - nearVector_ = value; - } - } else { - nearVectorBuilder_.mergeFrom(value); - } - if (nearVector_ != null) { - bitField0_ |= 0x00004000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public Builder clearNearVector() { - bitField0_ = (bitField0_ & ~0x00004000); - nearVector_ = null; - if (nearVectorBuilder_ != null) { - nearVectorBuilder_.dispose(); - nearVectorBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() { - bitField0_ |= 0x00004000; - onChanged(); - return getNearVectorFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() { - if (nearVectorBuilder_ != null) { - return nearVectorBuilder_.getMessageOrBuilder(); - } else { - return nearVector_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; - } - } - /** - * optional .weaviate.v1.NearVector near_vector = 43; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> - getNearVectorFieldBuilder() { - if (nearVectorBuilder_ == null) { - nearVectorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder>( - getNearVector(), - getParentForChildren(), - isClean()); - nearVector_ = null; - } - return nearVectorBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject nearObject_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder> nearObjectBuilder_; - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return Whether the nearObject field is set. - */ - public boolean hasNearObject() { - return ((bitField0_ & 0x00008000) != 0); - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - * @return The nearObject. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject() { - if (nearObjectBuilder_ == null) { - return nearObject_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; - } else { - return nearObjectBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public Builder setNearObject(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject value) { - if (nearObjectBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearObject_ = value; - } else { - nearObjectBuilder_.setMessage(value); - } - bitField0_ |= 0x00008000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public Builder setNearObject( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder builderForValue) { - if (nearObjectBuilder_ == null) { - nearObject_ = builderForValue.build(); - } else { - nearObjectBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00008000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public Builder mergeNearObject(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject value) { - if (nearObjectBuilder_ == null) { - if (((bitField0_ & 0x00008000) != 0) && - nearObject_ != null && - nearObject_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) { - getNearObjectBuilder().mergeFrom(value); - } else { - nearObject_ = value; - } - } else { - nearObjectBuilder_.mergeFrom(value); - } - if (nearObject_ != null) { - bitField0_ |= 0x00008000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public Builder clearNearObject() { - bitField0_ = (bitField0_ & ~0x00008000); - nearObject_ = null; - if (nearObjectBuilder_ != null) { - nearObjectBuilder_.dispose(); - nearObjectBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder getNearObjectBuilder() { - bitField0_ |= 0x00008000; - onChanged(); - return getNearObjectFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() { - if (nearObjectBuilder_ != null) { - return nearObjectBuilder_.getMessageOrBuilder(); - } else { - return nearObject_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; - } - } - /** - * optional .weaviate.v1.NearObject near_object = 44; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder> - getNearObjectFieldBuilder() { - if (nearObjectBuilder_ == null) { - nearObjectBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder>( - getNearObject(), - getParentForChildren(), - isClean()); - nearObject_ = null; - } - return nearObjectBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch nearText_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_; - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return Whether the nearText field is set. - */ - public boolean hasNearText() { - return ((bitField0_ & 0x00010000) != 0); - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - * @return The nearText. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() { - if (nearTextBuilder_ == null) { - return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; - } else { - return nearTextBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public Builder setNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) { - if (nearTextBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearText_ = value; - } else { - nearTextBuilder_.setMessage(value); - } - bitField0_ |= 0x00010000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public Builder setNearText( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) { - if (nearTextBuilder_ == null) { - nearText_ = builderForValue.build(); - } else { - nearTextBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00010000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public Builder mergeNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) { - if (nearTextBuilder_ == null) { - if (((bitField0_ & 0x00010000) != 0) && - nearText_ != null && - nearText_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) { - getNearTextBuilder().mergeFrom(value); - } else { - nearText_ = value; - } - } else { - nearTextBuilder_.mergeFrom(value); - } - if (nearText_ != null) { - bitField0_ |= 0x00010000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public Builder clearNearText() { - bitField0_ = (bitField0_ & ~0x00010000); - nearText_ = null; - if (nearTextBuilder_ != null) { - nearTextBuilder_.dispose(); - nearTextBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() { - bitField0_ |= 0x00010000; - onChanged(); - return getNearTextFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() { - if (nearTextBuilder_ != null) { - return nearTextBuilder_.getMessageOrBuilder(); - } else { - return nearText_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; - } - } - /** - * optional .weaviate.v1.NearTextSearch near_text = 45; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> - getNearTextFieldBuilder() { - if (nearTextBuilder_ == null) { - nearTextBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>( - getNearText(), - getParentForChildren(), - isClean()); - nearText_ = null; - } - return nearTextBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch nearImage_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> nearImageBuilder_; - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return Whether the nearImage field is set. - */ - public boolean hasNearImage() { - return ((bitField0_ & 0x00020000) != 0); - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - * @return The nearImage. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage() { - if (nearImageBuilder_ == null) { - return nearImage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; - } else { - return nearImageBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public Builder setNearImage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch value) { - if (nearImageBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearImage_ = value; - } else { - nearImageBuilder_.setMessage(value); - } - bitField0_ |= 0x00020000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public Builder setNearImage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder builderForValue) { - if (nearImageBuilder_ == null) { - nearImage_ = builderForValue.build(); - } else { - nearImageBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00020000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public Builder mergeNearImage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch value) { - if (nearImageBuilder_ == null) { - if (((bitField0_ & 0x00020000) != 0) && - nearImage_ != null && - nearImage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) { - getNearImageBuilder().mergeFrom(value); - } else { - nearImage_ = value; - } - } else { - nearImageBuilder_.mergeFrom(value); - } - if (nearImage_ != null) { - bitField0_ |= 0x00020000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public Builder clearNearImage() { - bitField0_ = (bitField0_ & ~0x00020000); - nearImage_ = null; - if (nearImageBuilder_ != null) { - nearImageBuilder_.dispose(); - nearImageBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder getNearImageBuilder() { - bitField0_ |= 0x00020000; - onChanged(); - return getNearImageFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() { - if (nearImageBuilder_ != null) { - return nearImageBuilder_.getMessageOrBuilder(); - } else { - return nearImage_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; - } - } - /** - * optional .weaviate.v1.NearImageSearch near_image = 46; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> - getNearImageFieldBuilder() { - if (nearImageBuilder_ == null) { - nearImageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder>( - getNearImage(), - getParentForChildren(), - isClean()); - nearImage_ = null; - } - return nearImageBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch nearAudio_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> nearAudioBuilder_; - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return Whether the nearAudio field is set. - */ - public boolean hasNearAudio() { - return ((bitField0_ & 0x00040000) != 0); - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - * @return The nearAudio. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() { - if (nearAudioBuilder_ == null) { - return nearAudio_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; - } else { - return nearAudioBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public Builder setNearAudio(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch value) { - if (nearAudioBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearAudio_ = value; - } else { - nearAudioBuilder_.setMessage(value); - } - bitField0_ |= 0x00040000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public Builder setNearAudio( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder builderForValue) { - if (nearAudioBuilder_ == null) { - nearAudio_ = builderForValue.build(); - } else { - nearAudioBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00040000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public Builder mergeNearAudio(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch value) { - if (nearAudioBuilder_ == null) { - if (((bitField0_ & 0x00040000) != 0) && - nearAudio_ != null && - nearAudio_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) { - getNearAudioBuilder().mergeFrom(value); - } else { - nearAudio_ = value; - } - } else { - nearAudioBuilder_.mergeFrom(value); - } - if (nearAudio_ != null) { - bitField0_ |= 0x00040000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public Builder clearNearAudio() { - bitField0_ = (bitField0_ & ~0x00040000); - nearAudio_ = null; - if (nearAudioBuilder_ != null) { - nearAudioBuilder_.dispose(); - nearAudioBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder getNearAudioBuilder() { - bitField0_ |= 0x00040000; - onChanged(); - return getNearAudioFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() { - if (nearAudioBuilder_ != null) { - return nearAudioBuilder_.getMessageOrBuilder(); - } else { - return nearAudio_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; - } - } - /** - * optional .weaviate.v1.NearAudioSearch near_audio = 47; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> - getNearAudioFieldBuilder() { - if (nearAudioBuilder_ == null) { - nearAudioBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder>( - getNearAudio(), - getParentForChildren(), - isClean()); - nearAudio_ = null; - } - return nearAudioBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch nearVideo_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> nearVideoBuilder_; - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return Whether the nearVideo field is set. - */ - public boolean hasNearVideo() { - return ((bitField0_ & 0x00080000) != 0); - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - * @return The nearVideo. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() { - if (nearVideoBuilder_ == null) { - return nearVideo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; - } else { - return nearVideoBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public Builder setNearVideo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch value) { - if (nearVideoBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearVideo_ = value; - } else { - nearVideoBuilder_.setMessage(value); - } - bitField0_ |= 0x00080000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public Builder setNearVideo( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder builderForValue) { - if (nearVideoBuilder_ == null) { - nearVideo_ = builderForValue.build(); - } else { - nearVideoBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00080000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public Builder mergeNearVideo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch value) { - if (nearVideoBuilder_ == null) { - if (((bitField0_ & 0x00080000) != 0) && - nearVideo_ != null && - nearVideo_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) { - getNearVideoBuilder().mergeFrom(value); - } else { - nearVideo_ = value; - } - } else { - nearVideoBuilder_.mergeFrom(value); - } - if (nearVideo_ != null) { - bitField0_ |= 0x00080000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public Builder clearNearVideo() { - bitField0_ = (bitField0_ & ~0x00080000); - nearVideo_ = null; - if (nearVideoBuilder_ != null) { - nearVideoBuilder_.dispose(); - nearVideoBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder getNearVideoBuilder() { - bitField0_ |= 0x00080000; - onChanged(); - return getNearVideoFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() { - if (nearVideoBuilder_ != null) { - return nearVideoBuilder_.getMessageOrBuilder(); - } else { - return nearVideo_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; - } - } - /** - * optional .weaviate.v1.NearVideoSearch near_video = 48; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> - getNearVideoFieldBuilder() { - if (nearVideoBuilder_ == null) { - nearVideoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder>( - getNearVideo(), - getParentForChildren(), - isClean()); - nearVideo_ = null; - } - return nearVideoBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch nearDepth_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> nearDepthBuilder_; - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return Whether the nearDepth field is set. - */ - public boolean hasNearDepth() { - return ((bitField0_ & 0x00100000) != 0); - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - * @return The nearDepth. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() { - if (nearDepthBuilder_ == null) { - return nearDepth_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; - } else { - return nearDepthBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public Builder setNearDepth(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch value) { - if (nearDepthBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearDepth_ = value; - } else { - nearDepthBuilder_.setMessage(value); - } - bitField0_ |= 0x00100000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public Builder setNearDepth( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder builderForValue) { - if (nearDepthBuilder_ == null) { - nearDepth_ = builderForValue.build(); - } else { - nearDepthBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00100000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public Builder mergeNearDepth(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch value) { - if (nearDepthBuilder_ == null) { - if (((bitField0_ & 0x00100000) != 0) && - nearDepth_ != null && - nearDepth_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) { - getNearDepthBuilder().mergeFrom(value); - } else { - nearDepth_ = value; - } - } else { - nearDepthBuilder_.mergeFrom(value); - } - if (nearDepth_ != null) { - bitField0_ |= 0x00100000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public Builder clearNearDepth() { - bitField0_ = (bitField0_ & ~0x00100000); - nearDepth_ = null; - if (nearDepthBuilder_ != null) { - nearDepthBuilder_.dispose(); - nearDepthBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder getNearDepthBuilder() { - bitField0_ |= 0x00100000; - onChanged(); - return getNearDepthFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() { - if (nearDepthBuilder_ != null) { - return nearDepthBuilder_.getMessageOrBuilder(); - } else { - return nearDepth_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; - } - } - /** - * optional .weaviate.v1.NearDepthSearch near_depth = 49; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> - getNearDepthFieldBuilder() { - if (nearDepthBuilder_ == null) { - nearDepthBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder>( - getNearDepth(), - getParentForChildren(), - isClean()); - nearDepth_ = null; - } - return nearDepthBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch nearThermal_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> nearThermalBuilder_; - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return Whether the nearThermal field is set. - */ - public boolean hasNearThermal() { - return ((bitField0_ & 0x00200000) != 0); - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - * @return The nearThermal. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() { - if (nearThermalBuilder_ == null) { - return nearThermal_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; - } else { - return nearThermalBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public Builder setNearThermal(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch value) { - if (nearThermalBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearThermal_ = value; - } else { - nearThermalBuilder_.setMessage(value); - } - bitField0_ |= 0x00200000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public Builder setNearThermal( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder builderForValue) { - if (nearThermalBuilder_ == null) { - nearThermal_ = builderForValue.build(); - } else { - nearThermalBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00200000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public Builder mergeNearThermal(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch value) { - if (nearThermalBuilder_ == null) { - if (((bitField0_ & 0x00200000) != 0) && - nearThermal_ != null && - nearThermal_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) { - getNearThermalBuilder().mergeFrom(value); - } else { - nearThermal_ = value; - } - } else { - nearThermalBuilder_.mergeFrom(value); - } - if (nearThermal_ != null) { - bitField0_ |= 0x00200000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public Builder clearNearThermal() { - bitField0_ = (bitField0_ & ~0x00200000); - nearThermal_ = null; - if (nearThermalBuilder_ != null) { - nearThermalBuilder_.dispose(); - nearThermalBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder getNearThermalBuilder() { - bitField0_ |= 0x00200000; - onChanged(); - return getNearThermalFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() { - if (nearThermalBuilder_ != null) { - return nearThermalBuilder_.getMessageOrBuilder(); - } else { - return nearThermal_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; - } - } - /** - * optional .weaviate.v1.NearThermalSearch near_thermal = 50; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> - getNearThermalFieldBuilder() { - if (nearThermalBuilder_ == null) { - nearThermalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder>( - getNearThermal(), - getParentForChildren(), - isClean()); - nearThermal_ = null; - } - return nearThermalBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch nearImu_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> nearImuBuilder_; - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return Whether the nearImu field is set. - */ - public boolean hasNearImu() { - return ((bitField0_ & 0x00400000) != 0); - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - * @return The nearImu. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() { - if (nearImuBuilder_ == null) { - return nearImu_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; - } else { - return nearImuBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public Builder setNearImu(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch value) { - if (nearImuBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nearImu_ = value; - } else { - nearImuBuilder_.setMessage(value); - } - bitField0_ |= 0x00400000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public Builder setNearImu( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder builderForValue) { - if (nearImuBuilder_ == null) { - nearImu_ = builderForValue.build(); - } else { - nearImuBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00400000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public Builder mergeNearImu(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch value) { - if (nearImuBuilder_ == null) { - if (((bitField0_ & 0x00400000) != 0) && - nearImu_ != null && - nearImu_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) { - getNearImuBuilder().mergeFrom(value); - } else { - nearImu_ = value; - } - } else { - nearImuBuilder_.mergeFrom(value); - } - if (nearImu_ != null) { - bitField0_ |= 0x00400000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public Builder clearNearImu() { - bitField0_ = (bitField0_ & ~0x00400000); - nearImu_ = null; - if (nearImuBuilder_ != null) { - nearImuBuilder_.dispose(); - nearImuBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder getNearImuBuilder() { - bitField0_ |= 0x00400000; - onChanged(); - return getNearImuFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() { - if (nearImuBuilder_ != null) { - return nearImuBuilder_.getMessageOrBuilder(); - } else { - return nearImu_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; - } - } - /** - * optional .weaviate.v1.NearIMUSearch near_imu = 51; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> - getNearImuFieldBuilder() { - if (nearImuBuilder_ == null) { - nearImuBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder>( - getNearImu(), - getParentForChildren(), - isClean()); - nearImu_ = null; - } - return nearImuBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch generative_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder> generativeBuilder_; - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return Whether the generative field is set. - */ - public boolean hasGenerative() { - return ((bitField0_ & 0x00800000) != 0); - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - * @return The generative. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getGenerative() { - if (generativeBuilder_ == null) { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; - } else { - return generativeBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public Builder setGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch value) { - if (generativeBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - generative_ = value; - } else { - generativeBuilder_.setMessage(value); - } - bitField0_ |= 0x00800000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public Builder setGenerative( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder builderForValue) { - if (generativeBuilder_ == null) { - generative_ = builderForValue.build(); - } else { - generativeBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00800000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public Builder mergeGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch value) { - if (generativeBuilder_ == null) { - if (((bitField0_ & 0x00800000) != 0) && - generative_ != null && - generative_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance()) { - getGenerativeBuilder().mergeFrom(value); - } else { - generative_ = value; - } - } else { - generativeBuilder_.mergeFrom(value); - } - if (generative_ != null) { - bitField0_ |= 0x00800000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public Builder clearGenerative() { - bitField0_ = (bitField0_ & ~0x00800000); - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder getGenerativeBuilder() { - bitField0_ |= 0x00800000; - onChanged(); - return getGenerativeFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder() { - if (generativeBuilder_ != null) { - return generativeBuilder_.getMessageOrBuilder(); - } else { - return generative_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; - } - } - /** - * optional .weaviate.v1.GenerativeSearch generative = 60; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder> - getGenerativeFieldBuilder() { - if (generativeBuilder_ == null) { - generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder>( - getGenerative(), - getParentForChildren(), - isClean()); - generative_ = null; - } - return generativeBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank rerank_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder> rerankBuilder_; - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return Whether the rerank field is set. - */ - public boolean hasRerank() { - return ((bitField0_ & 0x01000000) != 0); - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - * @return The rerank. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getRerank() { - if (rerankBuilder_ == null) { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; - } else { - return rerankBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public Builder setRerank(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank value) { - if (rerankBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - rerank_ = value; - } else { - rerankBuilder_.setMessage(value); - } - bitField0_ |= 0x01000000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public Builder setRerank( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder builderForValue) { - if (rerankBuilder_ == null) { - rerank_ = builderForValue.build(); - } else { - rerankBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x01000000; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public Builder mergeRerank(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank value) { - if (rerankBuilder_ == null) { - if (((bitField0_ & 0x01000000) != 0) && - rerank_ != null && - rerank_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance()) { - getRerankBuilder().mergeFrom(value); - } else { - rerank_ = value; - } - } else { - rerankBuilder_.mergeFrom(value); - } - if (rerank_ != null) { - bitField0_ |= 0x01000000; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public Builder clearRerank() { - bitField0_ = (bitField0_ & ~0x01000000); - rerank_ = null; - if (rerankBuilder_ != null) { - rerankBuilder_.dispose(); - rerankBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder getRerankBuilder() { - bitField0_ |= 0x01000000; - onChanged(); - return getRerankFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder() { - if (rerankBuilder_ != null) { - return rerankBuilder_.getMessageOrBuilder(); - } else { - return rerank_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; - } - } - /** - * optional .weaviate.v1.Rerank rerank = 61; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder> - getRerankFieldBuilder() { - if (rerankBuilder_ == null) { - rerankBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder>( - getRerank(), - getParentForChildren(), - isClean()); - rerank_ = null; - } - return rerankBuilder_; - } - - private boolean uses123Api_ ; - /** - * bool uses_123_api = 100 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. - * See v1/search_get.proto;l=51 - * @return The uses123Api. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getUses123Api() { - return uses123Api_; - } - /** - * bool uses_123_api = 100 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. - * See v1/search_get.proto;l=51 - * @param value The uses123Api to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setUses123Api(boolean value) { - - uses123Api_ = value; - bitField0_ |= 0x02000000; - onChanged(); - return this; - } - /** - * bool uses_123_api = 100 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. - * See v1/search_get.proto;l=51 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearUses123Api() { - bitField0_ = (bitField0_ & ~0x02000000); - uses123Api_ = false; - onChanged(); - return this; - } - - private boolean uses125Api_ ; - /** - * bool uses_125_api = 101 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. - * See v1/search_get.proto;l=52 - * @return The uses125Api. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getUses125Api() { - return uses125Api_; - } - /** - * bool uses_125_api = 101 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. - * See v1/search_get.proto;l=52 - * @param value The uses125Api to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setUses125Api(boolean value) { - - uses125Api_ = value; - bitField0_ |= 0x04000000; - onChanged(); - return this; - } - /** - * bool uses_125_api = 101 [deprecated = true]; - * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. - * See v1/search_get.proto;l=52 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearUses125Api() { - bitField0_ = (bitField0_ & ~0x04000000); - uses125Api_ = false; - onChanged(); - return this; - } - - private boolean uses127Api_ ; - /** - * bool uses_127_api = 102; - * @return The uses127Api. - */ - @java.lang.Override - public boolean getUses127Api() { - return uses127Api_; - } - /** - * bool uses_127_api = 102; - * @param value The uses127Api to set. - * @return This builder for chaining. - */ - public Builder setUses127Api(boolean value) { - - uses127Api_ = value; - bitField0_ |= 0x08000000; - onChanged(); - return this; - } - /** - * bool uses_127_api = 102; - * @return This builder for chaining. - */ - public Builder clearUses127Api() { - bitField0_ = (bitField0_ & ~0x08000000); - uses127Api_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.SearchRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SearchRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GroupByOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GroupBy) - com.google.protobuf.MessageOrBuilder { - - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @return A list containing the path. - */ - java.util.List - getPathList(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @return The count of path. - */ - int getPathCount(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @param index The index of the element to return. - * @return The path at the given index. - */ - java.lang.String getPath(int index); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - com.google.protobuf.ByteString - getPathBytes(int index); - - /** - * int32 number_of_groups = 2; - * @return The numberOfGroups. - */ - int getNumberOfGroups(); - - /** - * int32 objects_per_group = 3; - * @return The objectsPerGroup. - */ - int getObjectsPerGroup(); - } - /** - * Protobuf type {@code weaviate.v1.GroupBy} - */ - public static final class GroupBy extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GroupBy) - GroupByOrBuilder { - private static final long serialVersionUID = 0L; - // Use GroupBy.newBuilder() to construct. - private GroupBy(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GroupBy() { - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GroupBy(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder.class); - } - - public static final int PATH_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @return A list containing the path. - */ - public com.google.protobuf.ProtocolStringList - getPathList() { - return path_; - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @return The count of path. - */ - public int getPathCount() { - return path_.size(); - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @param index The index of the element to return. - * @return The path at the given index. - */ - public java.lang.String getPath(int index) { - return path_.get(index); - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But might
-     * be extended in the future.
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 1; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - public com.google.protobuf.ByteString - getPathBytes(int index) { - return path_.getByteString(index); - } - - public static final int NUMBER_OF_GROUPS_FIELD_NUMBER = 2; - private int numberOfGroups_ = 0; - /** - * int32 number_of_groups = 2; - * @return The numberOfGroups. - */ - @java.lang.Override - public int getNumberOfGroups() { - return numberOfGroups_; - } - - public static final int OBJECTS_PER_GROUP_FIELD_NUMBER = 3; - private int objectsPerGroup_ = 0; - /** - * int32 objects_per_group = 3; - * @return The objectsPerGroup. - */ - @java.lang.Override - public int getObjectsPerGroup() { - return objectsPerGroup_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < path_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, path_.getRaw(i)); - } - if (numberOfGroups_ != 0) { - output.writeInt32(2, numberOfGroups_); - } - if (objectsPerGroup_ != 0) { - output.writeInt32(3, objectsPerGroup_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < path_.size(); i++) { - dataSize += computeStringSizeNoTag(path_.getRaw(i)); - } - size += dataSize; - size += 1 * getPathList().size(); - } - if (numberOfGroups_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(2, numberOfGroups_); - } - if (objectsPerGroup_ != 0) { - size += com.google.protobuf.CodedOutputStream - .computeInt32Size(3, objectsPerGroup_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy) obj; - - if (!getPathList() - .equals(other.getPathList())) return false; - if (getNumberOfGroups() - != other.getNumberOfGroups()) return false; - if (getObjectsPerGroup() - != other.getObjectsPerGroup()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getPathCount() > 0) { - hash = (37 * hash) + PATH_FIELD_NUMBER; - hash = (53 * hash) + getPathList().hashCode(); - } - hash = (37 * hash) + NUMBER_OF_GROUPS_FIELD_NUMBER; - hash = (53 * hash) + getNumberOfGroups(); - hash = (37 * hash) + OBJECTS_PER_GROUP_FIELD_NUMBER; - hash = (53 * hash) + getObjectsPerGroup(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GroupBy} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GroupBy) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - numberOfGroups_ = 0; - objectsPerGroup_ = 0; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - path_.makeImmutable(); - result.path_ = path_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.numberOfGroups_ = numberOfGroups_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.objectsPerGroup_ = objectsPerGroup_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy.getDefaultInstance()) return this; - if (!other.path_.isEmpty()) { - if (path_.isEmpty()) { - path_ = other.path_; - bitField0_ |= 0x00000001; - } else { - ensurePathIsMutable(); - path_.addAll(other.path_); - } - onChanged(); - } - if (other.getNumberOfGroups() != 0) { - setNumberOfGroups(other.getNumberOfGroups()); - } - if (other.getObjectsPerGroup() != 0) { - setObjectsPerGroup(other.getObjectsPerGroup()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensurePathIsMutable(); - path_.add(s); - break; - } // case 10 - case 16: { - numberOfGroups_ = input.readInt32(); - bitField0_ |= 0x00000002; - break; - } // case 16 - case 24: { - objectsPerGroup_ = input.readInt32(); - bitField0_ |= 0x00000004; - break; - } // case 24 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensurePathIsMutable() { - if (!path_.isModifiable()) { - path_ = new com.google.protobuf.LazyStringArrayList(path_); - } - bitField0_ |= 0x00000001; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @return A list containing the path. - */ - public com.google.protobuf.ProtocolStringList - getPathList() { - path_.makeImmutable(); - return path_; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @return The count of path. - */ - public int getPathCount() { - return path_.size(); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param index The index of the element to return. - * @return The path at the given index. - */ - public java.lang.String getPath(int index) { - return path_.get(index); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - public com.google.protobuf.ByteString - getPathBytes(int index) { - return path_.getByteString(index); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param index The index to set the value at. - * @param value The path to set. - * @return This builder for chaining. - */ - public Builder setPath( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePathIsMutable(); - path_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param value The path to add. - * @return This builder for chaining. - */ - public Builder addPath( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePathIsMutable(); - path_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param values The path to add. - * @return This builder for chaining. - */ - public Builder addAllPath( - java.lang.Iterable values) { - ensurePathIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, path_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @return This builder for chaining. - */ - public Builder clearPath() { - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But might
-       * be extended in the future.
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 1; - * @param value The bytes of the path to add. - * @return This builder for chaining. - */ - public Builder addPathBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensurePathIsMutable(); - path_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private int numberOfGroups_ ; - /** - * int32 number_of_groups = 2; - * @return The numberOfGroups. - */ - @java.lang.Override - public int getNumberOfGroups() { - return numberOfGroups_; - } - /** - * int32 number_of_groups = 2; - * @param value The numberOfGroups to set. - * @return This builder for chaining. - */ - public Builder setNumberOfGroups(int value) { - - numberOfGroups_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * int32 number_of_groups = 2; - * @return This builder for chaining. - */ - public Builder clearNumberOfGroups() { - bitField0_ = (bitField0_ & ~0x00000002); - numberOfGroups_ = 0; - onChanged(); - return this; - } - - private int objectsPerGroup_ ; - /** - * int32 objects_per_group = 3; - * @return The objectsPerGroup. - */ - @java.lang.Override - public int getObjectsPerGroup() { - return objectsPerGroup_; - } - /** - * int32 objects_per_group = 3; - * @param value The objectsPerGroup to set. - * @return This builder for chaining. - */ - public Builder setObjectsPerGroup(int value) { - - objectsPerGroup_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * int32 objects_per_group = 3; - * @return This builder for chaining. - */ - public Builder clearObjectsPerGroup() { - bitField0_ = (bitField0_ & ~0x00000004); - objectsPerGroup_ = 0; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GroupBy) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GroupBy) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GroupBy parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupBy getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface SortByOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.SortBy) - com.google.protobuf.MessageOrBuilder { - - /** - * bool ascending = 1; - * @return The ascending. - */ - boolean getAscending(); - - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @return A list containing the path. - */ - java.util.List - getPathList(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @return The count of path. - */ - int getPathCount(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @param index The index of the element to return. - * @return The path at the given index. - */ - java.lang.String getPath(int index); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - com.google.protobuf.ByteString - getPathBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.SortBy} - */ - public static final class SortBy extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.SortBy) - SortByOrBuilder { - private static final long serialVersionUID = 0L; - // Use SortBy.newBuilder() to construct. - private SortBy(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SortBy() { - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SortBy(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder.class); - } - - public static final int ASCENDING_FIELD_NUMBER = 1; - private boolean ascending_ = false; - /** - * bool ascending = 1; - * @return The ascending. - */ - @java.lang.Override - public boolean getAscending() { - return ascending_; - } - - public static final int PATH_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @return A list containing the path. - */ - public com.google.protobuf.ProtocolStringList - getPathList() { - return path_; - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @return The count of path. - */ - public int getPathCount() { - return path_.size(); - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @param index The index of the element to return. - * @return The path at the given index. - */ - public java.lang.String getPath(int index) { - return path_.get(index); - } - /** - *
-     * currently only supports one entry (eg just properties, no refs). But the
-     * weaviate datastructure already has paths in it and this makes it easily
-     * extendable in the future
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated string path = 2; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - public com.google.protobuf.ByteString - getPathBytes(int index) { - return path_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (ascending_ != false) { - output.writeBool(1, ascending_); - } - for (int i = 0; i < path_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, path_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (ascending_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(1, ascending_); - } - { - int dataSize = 0; - for (int i = 0; i < path_.size(); i++) { - dataSize += computeStringSizeNoTag(path_.getRaw(i)); - } - size += dataSize; - size += 1 * getPathList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy) obj; - - if (getAscending() - != other.getAscending()) return false; - if (!getPathList() - .equals(other.getPathList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + ASCENDING_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getAscending()); - if (getPathCount() > 0) { - hash = (37 * hash) + PATH_FIELD_NUMBER; - hash = (53 * hash) + getPathList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.SortBy} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.SortBy) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortByOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - ascending_ = false; - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.ascending_ = ascending_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - path_.makeImmutable(); - result.path_ = path_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy.getDefaultInstance()) return this; - if (other.getAscending() != false) { - setAscending(other.getAscending()); - } - if (!other.path_.isEmpty()) { - if (path_.isEmpty()) { - path_ = other.path_; - bitField0_ |= 0x00000002; - } else { - ensurePathIsMutable(); - path_.addAll(other.path_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - ascending_ = input.readBool(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 18: { - java.lang.String s = input.readStringRequireUtf8(); - ensurePathIsMutable(); - path_.add(s); - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private boolean ascending_ ; - /** - * bool ascending = 1; - * @return The ascending. - */ - @java.lang.Override - public boolean getAscending() { - return ascending_; - } - /** - * bool ascending = 1; - * @param value The ascending to set. - * @return This builder for chaining. - */ - public Builder setAscending(boolean value) { - - ascending_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * bool ascending = 1; - * @return This builder for chaining. - */ - public Builder clearAscending() { - bitField0_ = (bitField0_ & ~0x00000001); - ascending_ = false; - onChanged(); - return this; - } - - private com.google.protobuf.LazyStringArrayList path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensurePathIsMutable() { - if (!path_.isModifiable()) { - path_ = new com.google.protobuf.LazyStringArrayList(path_); - } - bitField0_ |= 0x00000002; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @return A list containing the path. - */ - public com.google.protobuf.ProtocolStringList - getPathList() { - path_.makeImmutable(); - return path_; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @return The count of path. - */ - public int getPathCount() { - return path_.size(); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param index The index of the element to return. - * @return The path at the given index. - */ - public java.lang.String getPath(int index) { - return path_.get(index); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param index The index of the value to return. - * @return The bytes of the path at the given index. - */ - public com.google.protobuf.ByteString - getPathBytes(int index) { - return path_.getByteString(index); - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param index The index to set the value at. - * @param value The path to set. - * @return This builder for chaining. - */ - public Builder setPath( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePathIsMutable(); - path_.set(index, value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param value The path to add. - * @return This builder for chaining. - */ - public Builder addPath( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePathIsMutable(); - path_.add(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param values The path to add. - * @return This builder for chaining. - */ - public Builder addAllPath( - java.lang.Iterable values) { - ensurePathIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, path_); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @return This builder for chaining. - */ - public Builder clearPath() { - path_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002);; - onChanged(); - return this; - } - /** - *
-       * currently only supports one entry (eg just properties, no refs). But the
-       * weaviate datastructure already has paths in it and this makes it easily
-       * extendable in the future
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated string path = 2; - * @param value The bytes of the path to add. - * @return This builder for chaining. - */ - public Builder addPathBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensurePathIsMutable(); - path_.add(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.SortBy) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.SortBy) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SortBy parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SortBy getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface MetadataRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.MetadataRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * bool uuid = 1; - * @return The uuid. - */ - boolean getUuid(); - - /** - * bool vector = 2; - * @return The vector. - */ - boolean getVector(); - - /** - * bool creation_time_unix = 3; - * @return The creationTimeUnix. - */ - boolean getCreationTimeUnix(); - - /** - * bool last_update_time_unix = 4; - * @return The lastUpdateTimeUnix. - */ - boolean getLastUpdateTimeUnix(); - - /** - * bool distance = 5; - * @return The distance. - */ - boolean getDistance(); - - /** - * bool certainty = 6; - * @return The certainty. - */ - boolean getCertainty(); - - /** - * bool score = 7; - * @return The score. - */ - boolean getScore(); - - /** - * bool explain_score = 8; - * @return The explainScore. - */ - boolean getExplainScore(); - - /** - * bool is_consistent = 9; - * @return The isConsistent. - */ - boolean getIsConsistent(); - - /** - * repeated string vectors = 10; - * @return A list containing the vectors. - */ - java.util.List - getVectorsList(); - /** - * repeated string vectors = 10; - * @return The count of vectors. - */ - int getVectorsCount(); - /** - * repeated string vectors = 10; - * @param index The index of the element to return. - * @return The vectors at the given index. - */ - java.lang.String getVectors(int index); - /** - * repeated string vectors = 10; - * @param index The index of the value to return. - * @return The bytes of the vectors at the given index. - */ - com.google.protobuf.ByteString - getVectorsBytes(int index); - } - /** - * Protobuf type {@code weaviate.v1.MetadataRequest} - */ - public static final class MetadataRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.MetadataRequest) - MetadataRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use MetadataRequest.newBuilder() to construct. - private MetadataRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private MetadataRequest() { - vectors_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new MetadataRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder.class); - } - - public static final int UUID_FIELD_NUMBER = 1; - private boolean uuid_ = false; - /** - * bool uuid = 1; - * @return The uuid. - */ - @java.lang.Override - public boolean getUuid() { - return uuid_; - } - - public static final int VECTOR_FIELD_NUMBER = 2; - private boolean vector_ = false; - /** - * bool vector = 2; - * @return The vector. - */ - @java.lang.Override - public boolean getVector() { - return vector_; - } - - public static final int CREATION_TIME_UNIX_FIELD_NUMBER = 3; - private boolean creationTimeUnix_ = false; - /** - * bool creation_time_unix = 3; - * @return The creationTimeUnix. - */ - @java.lang.Override - public boolean getCreationTimeUnix() { - return creationTimeUnix_; - } - - public static final int LAST_UPDATE_TIME_UNIX_FIELD_NUMBER = 4; - private boolean lastUpdateTimeUnix_ = false; - /** - * bool last_update_time_unix = 4; - * @return The lastUpdateTimeUnix. - */ - @java.lang.Override - public boolean getLastUpdateTimeUnix() { - return lastUpdateTimeUnix_; - } - - public static final int DISTANCE_FIELD_NUMBER = 5; - private boolean distance_ = false; - /** - * bool distance = 5; - * @return The distance. - */ - @java.lang.Override - public boolean getDistance() { - return distance_; - } - - public static final int CERTAINTY_FIELD_NUMBER = 6; - private boolean certainty_ = false; - /** - * bool certainty = 6; - * @return The certainty. - */ - @java.lang.Override - public boolean getCertainty() { - return certainty_; - } - - public static final int SCORE_FIELD_NUMBER = 7; - private boolean score_ = false; - /** - * bool score = 7; - * @return The score. - */ - @java.lang.Override - public boolean getScore() { - return score_; - } - - public static final int EXPLAIN_SCORE_FIELD_NUMBER = 8; - private boolean explainScore_ = false; - /** - * bool explain_score = 8; - * @return The explainScore. - */ - @java.lang.Override - public boolean getExplainScore() { - return explainScore_; - } - - public static final int IS_CONSISTENT_FIELD_NUMBER = 9; - private boolean isConsistent_ = false; - /** - * bool is_consistent = 9; - * @return The isConsistent. - */ - @java.lang.Override - public boolean getIsConsistent() { - return isConsistent_; - } - - public static final int VECTORS_FIELD_NUMBER = 10; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList vectors_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string vectors = 10; - * @return A list containing the vectors. - */ - public com.google.protobuf.ProtocolStringList - getVectorsList() { - return vectors_; - } - /** - * repeated string vectors = 10; - * @return The count of vectors. - */ - public int getVectorsCount() { - return vectors_.size(); - } - /** - * repeated string vectors = 10; - * @param index The index of the element to return. - * @return The vectors at the given index. - */ - public java.lang.String getVectors(int index) { - return vectors_.get(index); - } - /** - * repeated string vectors = 10; - * @param index The index of the value to return. - * @return The bytes of the vectors at the given index. - */ - public com.google.protobuf.ByteString - getVectorsBytes(int index) { - return vectors_.getByteString(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (uuid_ != false) { - output.writeBool(1, uuid_); - } - if (vector_ != false) { - output.writeBool(2, vector_); - } - if (creationTimeUnix_ != false) { - output.writeBool(3, creationTimeUnix_); - } - if (lastUpdateTimeUnix_ != false) { - output.writeBool(4, lastUpdateTimeUnix_); - } - if (distance_ != false) { - output.writeBool(5, distance_); - } - if (certainty_ != false) { - output.writeBool(6, certainty_); - } - if (score_ != false) { - output.writeBool(7, score_); - } - if (explainScore_ != false) { - output.writeBool(8, explainScore_); - } - if (isConsistent_ != false) { - output.writeBool(9, isConsistent_); - } - for (int i = 0; i < vectors_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 10, vectors_.getRaw(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (uuid_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(1, uuid_); - } - if (vector_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(2, vector_); - } - if (creationTimeUnix_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(3, creationTimeUnix_); - } - if (lastUpdateTimeUnix_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(4, lastUpdateTimeUnix_); - } - if (distance_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(5, distance_); - } - if (certainty_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(6, certainty_); - } - if (score_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(7, score_); - } - if (explainScore_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(8, explainScore_); - } - if (isConsistent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(9, isConsistent_); - } - { - int dataSize = 0; - for (int i = 0; i < vectors_.size(); i++) { - dataSize += computeStringSizeNoTag(vectors_.getRaw(i)); - } - size += dataSize; - size += 1 * getVectorsList().size(); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest) obj; - - if (getUuid() - != other.getUuid()) return false; - if (getVector() - != other.getVector()) return false; - if (getCreationTimeUnix() - != other.getCreationTimeUnix()) return false; - if (getLastUpdateTimeUnix() - != other.getLastUpdateTimeUnix()) return false; - if (getDistance() - != other.getDistance()) return false; - if (getCertainty() - != other.getCertainty()) return false; - if (getScore() - != other.getScore()) return false; - if (getExplainScore() - != other.getExplainScore()) return false; - if (getIsConsistent() - != other.getIsConsistent()) return false; - if (!getVectorsList() - .equals(other.getVectorsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + UUID_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getUuid()); - hash = (37 * hash) + VECTOR_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getVector()); - hash = (37 * hash) + CREATION_TIME_UNIX_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getCreationTimeUnix()); - hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getLastUpdateTimeUnix()); - hash = (37 * hash) + DISTANCE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getDistance()); - hash = (37 * hash) + CERTAINTY_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getCertainty()); - hash = (37 * hash) + SCORE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getScore()); - hash = (37 * hash) + EXPLAIN_SCORE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getExplainScore()); - hash = (37 * hash) + IS_CONSISTENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsConsistent()); - if (getVectorsCount() > 0) { - hash = (37 * hash) + VECTORS_FIELD_NUMBER; - hash = (53 * hash) + getVectorsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.MetadataRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.MetadataRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - uuid_ = false; - vector_ = false; - creationTimeUnix_ = false; - lastUpdateTimeUnix_ = false; - distance_ = false; - certainty_ = false; - score_ = false; - explainScore_ = false; - isConsistent_ = false; - vectors_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.uuid_ = uuid_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.vector_ = vector_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.creationTimeUnix_ = creationTimeUnix_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.lastUpdateTimeUnix_ = lastUpdateTimeUnix_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.distance_ = distance_; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.certainty_ = certainty_; - } - if (((from_bitField0_ & 0x00000040) != 0)) { - result.score_ = score_; - } - if (((from_bitField0_ & 0x00000080) != 0)) { - result.explainScore_ = explainScore_; - } - if (((from_bitField0_ & 0x00000100) != 0)) { - result.isConsistent_ = isConsistent_; - } - if (((from_bitField0_ & 0x00000200) != 0)) { - vectors_.makeImmutable(); - result.vectors_ = vectors_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) return this; - if (other.getUuid() != false) { - setUuid(other.getUuid()); - } - if (other.getVector() != false) { - setVector(other.getVector()); - } - if (other.getCreationTimeUnix() != false) { - setCreationTimeUnix(other.getCreationTimeUnix()); - } - if (other.getLastUpdateTimeUnix() != false) { - setLastUpdateTimeUnix(other.getLastUpdateTimeUnix()); - } - if (other.getDistance() != false) { - setDistance(other.getDistance()); - } - if (other.getCertainty() != false) { - setCertainty(other.getCertainty()); - } - if (other.getScore() != false) { - setScore(other.getScore()); - } - if (other.getExplainScore() != false) { - setExplainScore(other.getExplainScore()); - } - if (other.getIsConsistent() != false) { - setIsConsistent(other.getIsConsistent()); - } - if (!other.vectors_.isEmpty()) { - if (vectors_.isEmpty()) { - vectors_ = other.vectors_; - bitField0_ |= 0x00000200; - } else { - ensureVectorsIsMutable(); - vectors_.addAll(other.vectors_); - } - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 8: { - uuid_ = input.readBool(); - bitField0_ |= 0x00000001; - break; - } // case 8 - case 16: { - vector_ = input.readBool(); - bitField0_ |= 0x00000002; - break; - } // case 16 - case 24: { - creationTimeUnix_ = input.readBool(); - bitField0_ |= 0x00000004; - break; - } // case 24 - case 32: { - lastUpdateTimeUnix_ = input.readBool(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 40: { - distance_ = input.readBool(); - bitField0_ |= 0x00000010; - break; - } // case 40 - case 48: { - certainty_ = input.readBool(); - bitField0_ |= 0x00000020; - break; - } // case 48 - case 56: { - score_ = input.readBool(); - bitField0_ |= 0x00000040; - break; - } // case 56 - case 64: { - explainScore_ = input.readBool(); - bitField0_ |= 0x00000080; - break; - } // case 64 - case 72: { - isConsistent_ = input.readBool(); - bitField0_ |= 0x00000100; - break; - } // case 72 - case 82: { - java.lang.String s = input.readStringRequireUtf8(); - ensureVectorsIsMutable(); - vectors_.add(s); - break; - } // case 82 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private boolean uuid_ ; - /** - * bool uuid = 1; - * @return The uuid. - */ - @java.lang.Override - public boolean getUuid() { - return uuid_; - } - /** - * bool uuid = 1; - * @param value The uuid to set. - * @return This builder for chaining. - */ - public Builder setUuid(boolean value) { - - uuid_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * bool uuid = 1; - * @return This builder for chaining. - */ - public Builder clearUuid() { - bitField0_ = (bitField0_ & ~0x00000001); - uuid_ = false; - onChanged(); - return this; - } - - private boolean vector_ ; - /** - * bool vector = 2; - * @return The vector. - */ - @java.lang.Override - public boolean getVector() { - return vector_; - } - /** - * bool vector = 2; - * @param value The vector to set. - * @return This builder for chaining. - */ - public Builder setVector(boolean value) { - - vector_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * bool vector = 2; - * @return This builder for chaining. - */ - public Builder clearVector() { - bitField0_ = (bitField0_ & ~0x00000002); - vector_ = false; - onChanged(); - return this; - } - - private boolean creationTimeUnix_ ; - /** - * bool creation_time_unix = 3; - * @return The creationTimeUnix. - */ - @java.lang.Override - public boolean getCreationTimeUnix() { - return creationTimeUnix_; - } - /** - * bool creation_time_unix = 3; - * @param value The creationTimeUnix to set. - * @return This builder for chaining. - */ - public Builder setCreationTimeUnix(boolean value) { - - creationTimeUnix_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * bool creation_time_unix = 3; - * @return This builder for chaining. - */ - public Builder clearCreationTimeUnix() { - bitField0_ = (bitField0_ & ~0x00000004); - creationTimeUnix_ = false; - onChanged(); - return this; - } - - private boolean lastUpdateTimeUnix_ ; - /** - * bool last_update_time_unix = 4; - * @return The lastUpdateTimeUnix. - */ - @java.lang.Override - public boolean getLastUpdateTimeUnix() { - return lastUpdateTimeUnix_; - } - /** - * bool last_update_time_unix = 4; - * @param value The lastUpdateTimeUnix to set. - * @return This builder for chaining. - */ - public Builder setLastUpdateTimeUnix(boolean value) { - - lastUpdateTimeUnix_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * bool last_update_time_unix = 4; - * @return This builder for chaining. - */ - public Builder clearLastUpdateTimeUnix() { - bitField0_ = (bitField0_ & ~0x00000008); - lastUpdateTimeUnix_ = false; - onChanged(); - return this; - } - - private boolean distance_ ; - /** - * bool distance = 5; - * @return The distance. - */ - @java.lang.Override - public boolean getDistance() { - return distance_; - } - /** - * bool distance = 5; - * @param value The distance to set. - * @return This builder for chaining. - */ - public Builder setDistance(boolean value) { - - distance_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * bool distance = 5; - * @return This builder for chaining. - */ - public Builder clearDistance() { - bitField0_ = (bitField0_ & ~0x00000010); - distance_ = false; - onChanged(); - return this; - } - - private boolean certainty_ ; - /** - * bool certainty = 6; - * @return The certainty. - */ - @java.lang.Override - public boolean getCertainty() { - return certainty_; - } - /** - * bool certainty = 6; - * @param value The certainty to set. - * @return This builder for chaining. - */ - public Builder setCertainty(boolean value) { - - certainty_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * bool certainty = 6; - * @return This builder for chaining. - */ - public Builder clearCertainty() { - bitField0_ = (bitField0_ & ~0x00000020); - certainty_ = false; - onChanged(); - return this; - } - - private boolean score_ ; - /** - * bool score = 7; - * @return The score. - */ - @java.lang.Override - public boolean getScore() { - return score_; - } - /** - * bool score = 7; - * @param value The score to set. - * @return This builder for chaining. - */ - public Builder setScore(boolean value) { - - score_ = value; - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - * bool score = 7; - * @return This builder for chaining. - */ - public Builder clearScore() { - bitField0_ = (bitField0_ & ~0x00000040); - score_ = false; - onChanged(); - return this; - } - - private boolean explainScore_ ; - /** - * bool explain_score = 8; - * @return The explainScore. - */ - @java.lang.Override - public boolean getExplainScore() { - return explainScore_; - } - /** - * bool explain_score = 8; - * @param value The explainScore to set. - * @return This builder for chaining. - */ - public Builder setExplainScore(boolean value) { - - explainScore_ = value; - bitField0_ |= 0x00000080; - onChanged(); - return this; - } - /** - * bool explain_score = 8; - * @return This builder for chaining. - */ - public Builder clearExplainScore() { - bitField0_ = (bitField0_ & ~0x00000080); - explainScore_ = false; - onChanged(); - return this; - } - - private boolean isConsistent_ ; - /** - * bool is_consistent = 9; - * @return The isConsistent. - */ - @java.lang.Override - public boolean getIsConsistent() { - return isConsistent_; - } - /** - * bool is_consistent = 9; - * @param value The isConsistent to set. - * @return This builder for chaining. - */ - public Builder setIsConsistent(boolean value) { - - isConsistent_ = value; - bitField0_ |= 0x00000100; - onChanged(); - return this; - } - /** - * bool is_consistent = 9; - * @return This builder for chaining. - */ - public Builder clearIsConsistent() { - bitField0_ = (bitField0_ & ~0x00000100); - isConsistent_ = false; - onChanged(); - return this; - } - - private com.google.protobuf.LazyStringArrayList vectors_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureVectorsIsMutable() { - if (!vectors_.isModifiable()) { - vectors_ = new com.google.protobuf.LazyStringArrayList(vectors_); - } - bitField0_ |= 0x00000200; - } - /** - * repeated string vectors = 10; - * @return A list containing the vectors. - */ - public com.google.protobuf.ProtocolStringList - getVectorsList() { - vectors_.makeImmutable(); - return vectors_; - } - /** - * repeated string vectors = 10; - * @return The count of vectors. - */ - public int getVectorsCount() { - return vectors_.size(); - } - /** - * repeated string vectors = 10; - * @param index The index of the element to return. - * @return The vectors at the given index. - */ - public java.lang.String getVectors(int index) { - return vectors_.get(index); - } - /** - * repeated string vectors = 10; - * @param index The index of the value to return. - * @return The bytes of the vectors at the given index. - */ - public com.google.protobuf.ByteString - getVectorsBytes(int index) { - return vectors_.getByteString(index); - } - /** - * repeated string vectors = 10; - * @param index The index to set the value at. - * @param value The vectors to set. - * @return This builder for chaining. - */ - public Builder setVectors( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureVectorsIsMutable(); - vectors_.set(index, value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - * repeated string vectors = 10; - * @param value The vectors to add. - * @return This builder for chaining. - */ - public Builder addVectors( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureVectorsIsMutable(); - vectors_.add(value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - * repeated string vectors = 10; - * @param values The vectors to add. - * @return This builder for chaining. - */ - public Builder addAllVectors( - java.lang.Iterable values) { - ensureVectorsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, vectors_); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - * repeated string vectors = 10; - * @return This builder for chaining. - */ - public Builder clearVectors() { - vectors_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000200);; - onChanged(); - return this; - } - /** - * repeated string vectors = 10; - * @param value The bytes of the vectors to add. - * @return This builder for chaining. - */ - public Builder addVectorsBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureVectorsIsMutable(); - vectors_.add(value); - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.MetadataRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.MetadataRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public MetadataRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface PropertiesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PropertiesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated string non_ref_properties = 1; - * @return A list containing the nonRefProperties. - */ - java.util.List - getNonRefPropertiesList(); - /** - * repeated string non_ref_properties = 1; - * @return The count of nonRefProperties. - */ - int getNonRefPropertiesCount(); - /** - * repeated string non_ref_properties = 1; - * @param index The index of the element to return. - * @return The nonRefProperties at the given index. - */ - java.lang.String getNonRefProperties(int index); - /** - * repeated string non_ref_properties = 1; - * @param index The index of the value to return. - * @return The bytes of the nonRefProperties at the given index. - */ - com.google.protobuf.ByteString - getNonRefPropertiesBytes(int index); - - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - java.util.List - getRefPropertiesList(); - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index); - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - int getRefPropertiesCount(); - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - java.util.List - getRefPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( - int index); - - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - java.util.List - getObjectPropertiesList(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - int getObjectPropertiesCount(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - java.util.List - getObjectPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index); - - /** - * bool return_all_nonref_properties = 11; - * @return The returnAllNonrefProperties. - */ - boolean getReturnAllNonrefProperties(); - } - /** - * Protobuf type {@code weaviate.v1.PropertiesRequest} - */ - public static final class PropertiesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PropertiesRequest) - PropertiesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use PropertiesRequest.newBuilder() to construct. - private PropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PropertiesRequest() { - nonRefProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - refProperties_ = java.util.Collections.emptyList(); - objectProperties_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PropertiesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder.class); - } - - public static final int NON_REF_PROPERTIES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList nonRefProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string non_ref_properties = 1; - * @return A list containing the nonRefProperties. - */ - public com.google.protobuf.ProtocolStringList - getNonRefPropertiesList() { - return nonRefProperties_; - } - /** - * repeated string non_ref_properties = 1; - * @return The count of nonRefProperties. - */ - public int getNonRefPropertiesCount() { - return nonRefProperties_.size(); - } - /** - * repeated string non_ref_properties = 1; - * @param index The index of the element to return. - * @return The nonRefProperties at the given index. - */ - public java.lang.String getNonRefProperties(int index) { - return nonRefProperties_.get(index); - } - /** - * repeated string non_ref_properties = 1; - * @param index The index of the value to return. - * @return The bytes of the nonRefProperties at the given index. - */ - public com.google.protobuf.ByteString - getNonRefPropertiesBytes(int index) { - return nonRefProperties_.getByteString(index); - } - - public static final int REF_PROPERTIES_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List refProperties_; - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - @java.lang.Override - public java.util.List getRefPropertiesList() { - return refProperties_; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - @java.lang.Override - public java.util.List - getRefPropertiesOrBuilderList() { - return refProperties_; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - @java.lang.Override - public int getRefPropertiesCount() { - return refProperties_.size(); - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index) { - return refProperties_.get(index); - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( - int index) { - return refProperties_.get(index); - } - - public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private java.util.List objectProperties_; - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public java.util.List getObjectPropertiesList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public java.util.List - getObjectPropertiesOrBuilderList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public int getObjectPropertiesCount() { - return objectProperties_.size(); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { - return objectProperties_.get(index); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index) { - return objectProperties_.get(index); - } - - public static final int RETURN_ALL_NONREF_PROPERTIES_FIELD_NUMBER = 11; - private boolean returnAllNonrefProperties_ = false; - /** - * bool return_all_nonref_properties = 11; - * @return The returnAllNonrefProperties. - */ - @java.lang.Override - public boolean getReturnAllNonrefProperties() { - return returnAllNonrefProperties_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < nonRefProperties_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, nonRefProperties_.getRaw(i)); - } - for (int i = 0; i < refProperties_.size(); i++) { - output.writeMessage(2, refProperties_.get(i)); - } - for (int i = 0; i < objectProperties_.size(); i++) { - output.writeMessage(3, objectProperties_.get(i)); - } - if (returnAllNonrefProperties_ != false) { - output.writeBool(11, returnAllNonrefProperties_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - { - int dataSize = 0; - for (int i = 0; i < nonRefProperties_.size(); i++) { - dataSize += computeStringSizeNoTag(nonRefProperties_.getRaw(i)); - } - size += dataSize; - size += 1 * getNonRefPropertiesList().size(); - } - for (int i = 0; i < refProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, refProperties_.get(i)); - } - for (int i = 0; i < objectProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, objectProperties_.get(i)); - } - if (returnAllNonrefProperties_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(11, returnAllNonrefProperties_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest) obj; - - if (!getNonRefPropertiesList() - .equals(other.getNonRefPropertiesList())) return false; - if (!getRefPropertiesList() - .equals(other.getRefPropertiesList())) return false; - if (!getObjectPropertiesList() - .equals(other.getObjectPropertiesList())) return false; - if (getReturnAllNonrefProperties() - != other.getReturnAllNonrefProperties()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getNonRefPropertiesCount() > 0) { - hash = (37 * hash) + NON_REF_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getNonRefPropertiesList().hashCode(); - } - if (getRefPropertiesCount() > 0) { - hash = (37 * hash) + REF_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getRefPropertiesList().hashCode(); - } - if (getObjectPropertiesCount() > 0) { - hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getObjectPropertiesList().hashCode(); - } - hash = (37 * hash) + RETURN_ALL_NONREF_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getReturnAllNonrefProperties()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PropertiesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PropertiesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - nonRefProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - if (refPropertiesBuilder_ == null) { - refProperties_ = java.util.Collections.emptyList(); - } else { - refProperties_ = null; - refPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000002); - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - } else { - objectProperties_ = null; - objectPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000004); - returnAllNonrefProperties_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest result) { - if (refPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0)) { - refProperties_ = java.util.Collections.unmodifiableList(refProperties_); - bitField0_ = (bitField0_ & ~0x00000002); - } - result.refProperties_ = refProperties_; - } else { - result.refProperties_ = refPropertiesBuilder_.build(); - } - if (objectPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0)) { - objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); - bitField0_ = (bitField0_ & ~0x00000004); - } - result.objectProperties_ = objectProperties_; - } else { - result.objectProperties_ = objectPropertiesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - nonRefProperties_.makeImmutable(); - result.nonRefProperties_ = nonRefProperties_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.returnAllNonrefProperties_ = returnAllNonrefProperties_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) return this; - if (!other.nonRefProperties_.isEmpty()) { - if (nonRefProperties_.isEmpty()) { - nonRefProperties_ = other.nonRefProperties_; - bitField0_ |= 0x00000001; - } else { - ensureNonRefPropertiesIsMutable(); - nonRefProperties_.addAll(other.nonRefProperties_); - } - onChanged(); - } - if (refPropertiesBuilder_ == null) { - if (!other.refProperties_.isEmpty()) { - if (refProperties_.isEmpty()) { - refProperties_ = other.refProperties_; - bitField0_ = (bitField0_ & ~0x00000002); - } else { - ensureRefPropertiesIsMutable(); - refProperties_.addAll(other.refProperties_); - } - onChanged(); - } - } else { - if (!other.refProperties_.isEmpty()) { - if (refPropertiesBuilder_.isEmpty()) { - refPropertiesBuilder_.dispose(); - refPropertiesBuilder_ = null; - refProperties_ = other.refProperties_; - bitField0_ = (bitField0_ & ~0x00000002); - refPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getRefPropertiesFieldBuilder() : null; - } else { - refPropertiesBuilder_.addAllMessages(other.refProperties_); - } - } - } - if (objectPropertiesBuilder_ == null) { - if (!other.objectProperties_.isEmpty()) { - if (objectProperties_.isEmpty()) { - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000004); - } else { - ensureObjectPropertiesIsMutable(); - objectProperties_.addAll(other.objectProperties_); - } - onChanged(); - } - } else { - if (!other.objectProperties_.isEmpty()) { - if (objectPropertiesBuilder_.isEmpty()) { - objectPropertiesBuilder_.dispose(); - objectPropertiesBuilder_ = null; - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000004); - objectPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectPropertiesFieldBuilder() : null; - } else { - objectPropertiesBuilder_.addAllMessages(other.objectProperties_); - } - } - } - if (other.getReturnAllNonrefProperties() != false) { - setReturnAllNonrefProperties(other.getReturnAllNonrefProperties()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - java.lang.String s = input.readStringRequireUtf8(); - ensureNonRefPropertiesIsMutable(); - nonRefProperties_.add(s); - break; - } // case 10 - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.parser(), - extensionRegistry); - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - refProperties_.add(m); - } else { - refPropertiesBuilder_.addMessage(m); - } - break; - } // case 18 - case 26: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.parser(), - extensionRegistry); - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(m); - } else { - objectPropertiesBuilder_.addMessage(m); - } - break; - } // case 26 - case 88: { - returnAllNonrefProperties_ = input.readBool(); - bitField0_ |= 0x00000008; - break; - } // case 88 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private com.google.protobuf.LazyStringArrayList nonRefProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensureNonRefPropertiesIsMutable() { - if (!nonRefProperties_.isModifiable()) { - nonRefProperties_ = new com.google.protobuf.LazyStringArrayList(nonRefProperties_); - } - bitField0_ |= 0x00000001; - } - /** - * repeated string non_ref_properties = 1; - * @return A list containing the nonRefProperties. - */ - public com.google.protobuf.ProtocolStringList - getNonRefPropertiesList() { - nonRefProperties_.makeImmutable(); - return nonRefProperties_; - } - /** - * repeated string non_ref_properties = 1; - * @return The count of nonRefProperties. - */ - public int getNonRefPropertiesCount() { - return nonRefProperties_.size(); - } - /** - * repeated string non_ref_properties = 1; - * @param index The index of the element to return. - * @return The nonRefProperties at the given index. - */ - public java.lang.String getNonRefProperties(int index) { - return nonRefProperties_.get(index); - } - /** - * repeated string non_ref_properties = 1; - * @param index The index of the value to return. - * @return The bytes of the nonRefProperties at the given index. - */ - public com.google.protobuf.ByteString - getNonRefPropertiesBytes(int index) { - return nonRefProperties_.getByteString(index); - } - /** - * repeated string non_ref_properties = 1; - * @param index The index to set the value at. - * @param value The nonRefProperties to set. - * @return This builder for chaining. - */ - public Builder setNonRefProperties( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureNonRefPropertiesIsMutable(); - nonRefProperties_.set(index, value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string non_ref_properties = 1; - * @param value The nonRefProperties to add. - * @return This builder for chaining. - */ - public Builder addNonRefProperties( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensureNonRefPropertiesIsMutable(); - nonRefProperties_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string non_ref_properties = 1; - * @param values The nonRefProperties to add. - * @return This builder for chaining. - */ - public Builder addAllNonRefProperties( - java.lang.Iterable values) { - ensureNonRefPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, nonRefProperties_); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * repeated string non_ref_properties = 1; - * @return This builder for chaining. - */ - public Builder clearNonRefProperties() { - nonRefProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001);; - onChanged(); - return this; - } - /** - * repeated string non_ref_properties = 1; - * @param value The bytes of the nonRefProperties to add. - * @return This builder for chaining. - */ - public Builder addNonRefPropertiesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensureNonRefPropertiesIsMutable(); - nonRefProperties_.add(value); - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.util.List refProperties_ = - java.util.Collections.emptyList(); - private void ensureRefPropertiesIsMutable() { - if (!((bitField0_ & 0x00000002) != 0)) { - refProperties_ = new java.util.ArrayList(refProperties_); - bitField0_ |= 0x00000002; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder> refPropertiesBuilder_; - - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public java.util.List getRefPropertiesList() { - if (refPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(refProperties_); - } else { - return refPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public int getRefPropertiesCount() { - if (refPropertiesBuilder_ == null) { - return refProperties_.size(); - } else { - return refPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index) { - if (refPropertiesBuilder_ == null) { - return refProperties_.get(index); - } else { - return refPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder setRefProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest value) { - if (refPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropertiesIsMutable(); - refProperties_.set(index, value); - onChanged(); - } else { - refPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder setRefProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - refProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - refPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder addRefProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest value) { - if (refPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropertiesIsMutable(); - refProperties_.add(value); - onChanged(); - } else { - refPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder addRefProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest value) { - if (refPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropertiesIsMutable(); - refProperties_.add(index, value); - onChanged(); - } else { - refPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder addRefProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - refProperties_.add(builderForValue.build()); - onChanged(); - } else { - refPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder addRefProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - refProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - refPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder addAllRefProperties( - java.lang.Iterable values) { - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, refProperties_); - onChanged(); - } else { - refPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder clearRefProperties() { - if (refPropertiesBuilder_ == null) { - refProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - } else { - refPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public Builder removeRefProperties(int index) { - if (refPropertiesBuilder_ == null) { - ensureRefPropertiesIsMutable(); - refProperties_.remove(index); - onChanged(); - } else { - refPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder getRefPropertiesBuilder( - int index) { - return getRefPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( - int index) { - if (refPropertiesBuilder_ == null) { - return refProperties_.get(index); } else { - return refPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public java.util.List - getRefPropertiesOrBuilderList() { - if (refPropertiesBuilder_ != null) { - return refPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(refProperties_); - } - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder addRefPropertiesBuilder() { - return getRefPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder addRefPropertiesBuilder( - int index) { - return getRefPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; - */ - public java.util.List - getRefPropertiesBuilderList() { - return getRefPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder> - getRefPropertiesFieldBuilder() { - if (refPropertiesBuilder_ == null) { - refPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder>( - refProperties_, - ((bitField0_ & 0x00000002) != 0), - getParentForChildren(), - isClean()); - refProperties_ = null; - } - return refPropertiesBuilder_; - } - - private java.util.List objectProperties_ = - java.util.Collections.emptyList(); - private void ensureObjectPropertiesIsMutable() { - if (!((bitField0_ & 0x00000004) != 0)) { - objectProperties_ = new java.util.ArrayList(objectProperties_); - bitField0_ |= 0x00000004; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> objectPropertiesBuilder_; - - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List getObjectPropertiesList() { - if (objectPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(objectProperties_); - } else { - return objectPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public int getObjectPropertiesCount() { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.size(); - } else { - return objectPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); - } else { - return objectPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addAllObjectProperties( - java.lang.Iterable values) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objectProperties_); - onChanged(); - } else { - objectPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder clearObjectProperties() { - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - } else { - objectPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder removeObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.remove(index); - onChanged(); - } else { - objectPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder getObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); } else { - return objectPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List - getObjectPropertiesOrBuilderList() { - if (objectPropertiesBuilder_ != null) { - return objectPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objectProperties_); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder() { - return getObjectPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List - getObjectPropertiesBuilderList() { - return getObjectPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> - getObjectPropertiesFieldBuilder() { - if (objectPropertiesBuilder_ == null) { - objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder>( - objectProperties_, - ((bitField0_ & 0x00000004) != 0), - getParentForChildren(), - isClean()); - objectProperties_ = null; - } - return objectPropertiesBuilder_; - } - - private boolean returnAllNonrefProperties_ ; - /** - * bool return_all_nonref_properties = 11; - * @return The returnAllNonrefProperties. - */ - @java.lang.Override - public boolean getReturnAllNonrefProperties() { - return returnAllNonrefProperties_; - } - /** - * bool return_all_nonref_properties = 11; - * @param value The returnAllNonrefProperties to set. - * @return This builder for chaining. - */ - public Builder setReturnAllNonrefProperties(boolean value) { - - returnAllNonrefProperties_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * bool return_all_nonref_properties = 11; - * @return This builder for chaining. - */ - public Builder clearReturnAllNonrefProperties() { - bitField0_ = (bitField0_ & ~0x00000008); - returnAllNonrefProperties_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PropertiesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PropertiesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PropertiesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface ObjectPropertiesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.ObjectPropertiesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string prop_name = 1; - * @return The propName. - */ - java.lang.String getPropName(); - /** - * string prop_name = 1; - * @return The bytes for propName. - */ - com.google.protobuf.ByteString - getPropNameBytes(); - - /** - * repeated string primitive_properties = 2; - * @return A list containing the primitiveProperties. - */ - java.util.List - getPrimitivePropertiesList(); - /** - * repeated string primitive_properties = 2; - * @return The count of primitiveProperties. - */ - int getPrimitivePropertiesCount(); - /** - * repeated string primitive_properties = 2; - * @param index The index of the element to return. - * @return The primitiveProperties at the given index. - */ - java.lang.String getPrimitiveProperties(int index); - /** - * repeated string primitive_properties = 2; - * @param index The index of the value to return. - * @return The bytes of the primitiveProperties at the given index. - */ - com.google.protobuf.ByteString - getPrimitivePropertiesBytes(int index); - - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - java.util.List - getObjectPropertiesList(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - int getObjectPropertiesCount(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - java.util.List - getObjectPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.ObjectPropertiesRequest} - */ - public static final class ObjectPropertiesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.ObjectPropertiesRequest) - ObjectPropertiesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use ObjectPropertiesRequest.newBuilder() to construct. - private ObjectPropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private ObjectPropertiesRequest() { - propName_ = ""; - primitiveProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - objectProperties_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new ObjectPropertiesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder.class); - } - - public static final int PROP_NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object propName_ = ""; - /** - * string prop_name = 1; - * @return The propName. - */ - @java.lang.Override - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } - } - /** - * string prop_name = 1; - * @return The bytes for propName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int PRIMITIVE_PROPERTIES_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private com.google.protobuf.LazyStringArrayList primitiveProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - /** - * repeated string primitive_properties = 2; - * @return A list containing the primitiveProperties. - */ - public com.google.protobuf.ProtocolStringList - getPrimitivePropertiesList() { - return primitiveProperties_; - } - /** - * repeated string primitive_properties = 2; - * @return The count of primitiveProperties. - */ - public int getPrimitivePropertiesCount() { - return primitiveProperties_.size(); - } - /** - * repeated string primitive_properties = 2; - * @param index The index of the element to return. - * @return The primitiveProperties at the given index. - */ - public java.lang.String getPrimitiveProperties(int index) { - return primitiveProperties_.get(index); - } - /** - * repeated string primitive_properties = 2; - * @param index The index of the value to return. - * @return The bytes of the primitiveProperties at the given index. - */ - public com.google.protobuf.ByteString - getPrimitivePropertiesBytes(int index) { - return primitiveProperties_.getByteString(index); - } - - public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private java.util.List objectProperties_; - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public java.util.List getObjectPropertiesList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public java.util.List - getObjectPropertiesOrBuilderList() { - return objectProperties_; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public int getObjectPropertiesCount() { - return objectProperties_.size(); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { - return objectProperties_.get(index); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index) { - return objectProperties_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, propName_); - } - for (int i = 0; i < primitiveProperties_.size(); i++) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, primitiveProperties_.getRaw(i)); - } - for (int i = 0; i < objectProperties_.size(); i++) { - output.writeMessage(3, objectProperties_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, propName_); - } - { - int dataSize = 0; - for (int i = 0; i < primitiveProperties_.size(); i++) { - dataSize += computeStringSizeNoTag(primitiveProperties_.getRaw(i)); - } - size += dataSize; - size += 1 * getPrimitivePropertiesList().size(); - } - for (int i = 0; i < objectProperties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, objectProperties_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest) obj; - - if (!getPropName() - .equals(other.getPropName())) return false; - if (!getPrimitivePropertiesList() - .equals(other.getPrimitivePropertiesList())) return false; - if (!getObjectPropertiesList() - .equals(other.getObjectPropertiesList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; - hash = (53 * hash) + getPropName().hashCode(); - if (getPrimitivePropertiesCount() > 0) { - hash = (37 * hash) + PRIMITIVE_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getPrimitivePropertiesList().hashCode(); - } - if (getObjectPropertiesCount() > 0) { - hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getObjectPropertiesList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.ObjectPropertiesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectPropertiesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - propName_ = ""; - primitiveProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - } else { - objectProperties_ = null; - objectPropertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000004); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest result) { - if (objectPropertiesBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0)) { - objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); - bitField0_ = (bitField0_ & ~0x00000004); - } - result.objectProperties_ = objectProperties_; - } else { - result.objectProperties_ = objectPropertiesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.propName_ = propName_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - primitiveProperties_.makeImmutable(); - result.primitiveProperties_ = primitiveProperties_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()) return this; - if (!other.getPropName().isEmpty()) { - propName_ = other.propName_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.primitiveProperties_.isEmpty()) { - if (primitiveProperties_.isEmpty()) { - primitiveProperties_ = other.primitiveProperties_; - bitField0_ |= 0x00000002; - } else { - ensurePrimitivePropertiesIsMutable(); - primitiveProperties_.addAll(other.primitiveProperties_); - } - onChanged(); - } - if (objectPropertiesBuilder_ == null) { - if (!other.objectProperties_.isEmpty()) { - if (objectProperties_.isEmpty()) { - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000004); - } else { - ensureObjectPropertiesIsMutable(); - objectProperties_.addAll(other.objectProperties_); - } - onChanged(); - } - } else { - if (!other.objectProperties_.isEmpty()) { - if (objectPropertiesBuilder_.isEmpty()) { - objectPropertiesBuilder_.dispose(); - objectPropertiesBuilder_ = null; - objectProperties_ = other.objectProperties_; - bitField0_ = (bitField0_ & ~0x00000004); - objectPropertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectPropertiesFieldBuilder() : null; - } else { - objectPropertiesBuilder_.addAllMessages(other.objectProperties_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - propName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - java.lang.String s = input.readStringRequireUtf8(); - ensurePrimitivePropertiesIsMutable(); - primitiveProperties_.add(s); - break; - } // case 18 - case 26: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.parser(), - extensionRegistry); - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(m); - } else { - objectPropertiesBuilder_.addMessage(m); - } - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object propName_ = ""; - /** - * string prop_name = 1; - * @return The propName. - */ - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string prop_name = 1; - * @return The bytes for propName. - */ - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string prop_name = 1; - * @param value The propName to set. - * @return This builder for chaining. - */ - public Builder setPropName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - propName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string prop_name = 1; - * @return This builder for chaining. - */ - public Builder clearPropName() { - propName_ = getDefaultInstance().getPropName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string prop_name = 1; - * @param value The bytes for propName to set. - * @return This builder for chaining. - */ - public Builder setPropNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - propName_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private com.google.protobuf.LazyStringArrayList primitiveProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - private void ensurePrimitivePropertiesIsMutable() { - if (!primitiveProperties_.isModifiable()) { - primitiveProperties_ = new com.google.protobuf.LazyStringArrayList(primitiveProperties_); - } - bitField0_ |= 0x00000002; - } - /** - * repeated string primitive_properties = 2; - * @return A list containing the primitiveProperties. - */ - public com.google.protobuf.ProtocolStringList - getPrimitivePropertiesList() { - primitiveProperties_.makeImmutable(); - return primitiveProperties_; - } - /** - * repeated string primitive_properties = 2; - * @return The count of primitiveProperties. - */ - public int getPrimitivePropertiesCount() { - return primitiveProperties_.size(); - } - /** - * repeated string primitive_properties = 2; - * @param index The index of the element to return. - * @return The primitiveProperties at the given index. - */ - public java.lang.String getPrimitiveProperties(int index) { - return primitiveProperties_.get(index); - } - /** - * repeated string primitive_properties = 2; - * @param index The index of the value to return. - * @return The bytes of the primitiveProperties at the given index. - */ - public com.google.protobuf.ByteString - getPrimitivePropertiesBytes(int index) { - return primitiveProperties_.getByteString(index); - } - /** - * repeated string primitive_properties = 2; - * @param index The index to set the value at. - * @param value The primitiveProperties to set. - * @return This builder for chaining. - */ - public Builder setPrimitiveProperties( - int index, java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePrimitivePropertiesIsMutable(); - primitiveProperties_.set(index, value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * repeated string primitive_properties = 2; - * @param value The primitiveProperties to add. - * @return This builder for chaining. - */ - public Builder addPrimitiveProperties( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - ensurePrimitivePropertiesIsMutable(); - primitiveProperties_.add(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * repeated string primitive_properties = 2; - * @param values The primitiveProperties to add. - * @return This builder for chaining. - */ - public Builder addAllPrimitiveProperties( - java.lang.Iterable values) { - ensurePrimitivePropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, primitiveProperties_); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * repeated string primitive_properties = 2; - * @return This builder for chaining. - */ - public Builder clearPrimitiveProperties() { - primitiveProperties_ = - com.google.protobuf.LazyStringArrayList.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002);; - onChanged(); - return this; - } - /** - * repeated string primitive_properties = 2; - * @param value The bytes of the primitiveProperties to add. - * @return This builder for chaining. - */ - public Builder addPrimitivePropertiesBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - ensurePrimitivePropertiesIsMutable(); - primitiveProperties_.add(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private java.util.List objectProperties_ = - java.util.Collections.emptyList(); - private void ensureObjectPropertiesIsMutable() { - if (!((bitField0_ & 0x00000004) != 0)) { - objectProperties_ = new java.util.ArrayList(objectProperties_); - bitField0_ |= 0x00000004; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> objectPropertiesBuilder_; - - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List getObjectPropertiesList() { - if (objectPropertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(objectProperties_); - } else { - return objectPropertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public int getObjectPropertiesCount() { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.size(); - } else { - return objectPropertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); - } else { - return objectPropertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder setObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.set(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { - if (objectPropertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, value); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addObjectProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.add(index, builderForValue.build()); - onChanged(); - } else { - objectPropertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder addAllObjectProperties( - java.lang.Iterable values) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objectProperties_); - onChanged(); - } else { - objectPropertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder clearObjectProperties() { - if (objectPropertiesBuilder_ == null) { - objectProperties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - } else { - objectPropertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public Builder removeObjectProperties(int index) { - if (objectPropertiesBuilder_ == null) { - ensureObjectPropertiesIsMutable(); - objectProperties_.remove(index); - onChanged(); - } else { - objectPropertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder getObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( - int index) { - if (objectPropertiesBuilder_ == null) { - return objectProperties_.get(index); } else { - return objectPropertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List - getObjectPropertiesOrBuilderList() { - if (objectPropertiesBuilder_ != null) { - return objectPropertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objectProperties_); - } - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder() { - return getObjectPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder( - int index) { - return getObjectPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; - */ - public java.util.List - getObjectPropertiesBuilderList() { - return getObjectPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> - getObjectPropertiesFieldBuilder() { - if (objectPropertiesBuilder_ == null) { - objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder>( - objectProperties_, - ((bitField0_ & 0x00000004) != 0), - getParentForChildren(), - isClean()); - objectProperties_ = null; - } - return objectPropertiesBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.ObjectPropertiesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectPropertiesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public ObjectPropertiesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface RefPropertiesRequestOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.RefPropertiesRequest) - com.google.protobuf.MessageOrBuilder { - - /** - * string reference_property = 1; - * @return The referenceProperty. - */ - java.lang.String getReferenceProperty(); - /** - * string reference_property = 1; - * @return The bytes for referenceProperty. - */ - com.google.protobuf.ByteString - getReferencePropertyBytes(); - - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return Whether the properties field is set. - */ - boolean hasProperties(); - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return The properties. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties(); - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder(); - - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return Whether the metadata field is set. - */ - boolean hasMetadata(); - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return The metadata. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata(); - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder(); - - /** - * string target_collection = 4; - * @return The targetCollection. - */ - java.lang.String getTargetCollection(); - /** - * string target_collection = 4; - * @return The bytes for targetCollection. - */ - com.google.protobuf.ByteString - getTargetCollectionBytes(); - } - /** - * Protobuf type {@code weaviate.v1.RefPropertiesRequest} - */ - public static final class RefPropertiesRequest extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.RefPropertiesRequest) - RefPropertiesRequestOrBuilder { - private static final long serialVersionUID = 0L; - // Use RefPropertiesRequest.newBuilder() to construct. - private RefPropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private RefPropertiesRequest() { - referenceProperty_ = ""; - targetCollection_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new RefPropertiesRequest(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder.class); - } - - private int bitField0_; - public static final int REFERENCE_PROPERTY_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object referenceProperty_ = ""; - /** - * string reference_property = 1; - * @return The referenceProperty. - */ - @java.lang.Override - public java.lang.String getReferenceProperty() { - java.lang.Object ref = referenceProperty_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - referenceProperty_ = s; - return s; - } - } - /** - * string reference_property = 1; - * @return The bytes for referenceProperty. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getReferencePropertyBytes() { - java.lang.Object ref = referenceProperty_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - referenceProperty_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int PROPERTIES_FIELD_NUMBER = 2; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest properties_; - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return Whether the properties field is set. - */ - @java.lang.Override - public boolean hasProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return The properties. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - - public static final int METADATA_FIELD_NUMBER = 3; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest metadata_; - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return Whether the metadata field is set. - */ - @java.lang.Override - public boolean hasMetadata() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return The metadata. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - - public static final int TARGET_COLLECTION_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private volatile java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 4; - * @return The targetCollection. - */ - @java.lang.Override - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } - } - /** - * string target_collection = 4; - * @return The bytes for targetCollection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(referenceProperty_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, referenceProperty_); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(2, getProperties()); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(3, getMetadata()); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 4, targetCollection_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(referenceProperty_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, referenceProperty_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, getProperties()); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, getMetadata()); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, targetCollection_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest) obj; - - if (!getReferenceProperty() - .equals(other.getReferenceProperty())) return false; - if (hasProperties() != other.hasProperties()) return false; - if (hasProperties()) { - if (!getProperties() - .equals(other.getProperties())) return false; - } - if (hasMetadata() != other.hasMetadata()) return false; - if (hasMetadata()) { - if (!getMetadata() - .equals(other.getMetadata())) return false; - } - if (!getTargetCollection() - .equals(other.getTargetCollection())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + REFERENCE_PROPERTY_FIELD_NUMBER; - hash = (53 * hash) + getReferenceProperty().hashCode(); - if (hasProperties()) { - hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getProperties().hashCode(); - } - if (hasMetadata()) { - hash = (37 * hash) + METADATA_FIELD_NUMBER; - hash = (53 * hash) + getMetadata().hashCode(); - } - hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getTargetCollection().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.RefPropertiesRequest} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.RefPropertiesRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getPropertiesFieldBuilder(); - getMetadataFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - referenceProperty_ = ""; - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - targetCollection_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.referenceProperty_ = referenceProperty_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.properties_ = propertiesBuilder_ == null - ? properties_ - : propertiesBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.metadata_ = metadataBuilder_ == null - ? metadata_ - : metadataBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.targetCollection_ = targetCollection_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()) return this; - if (!other.getReferenceProperty().isEmpty()) { - referenceProperty_ = other.referenceProperty_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (other.hasProperties()) { - mergeProperties(other.getProperties()); - } - if (other.hasMetadata()) { - mergeMetadata(other.getMetadata()); - } - if (!other.getTargetCollection().isEmpty()) { - targetCollection_ = other.targetCollection_; - bitField0_ |= 0x00000008; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - referenceProperty_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - input.readMessage( - getPropertiesFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - input.readMessage( - getMetadataFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 34: { - targetCollection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000008; - break; - } // case 34 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object referenceProperty_ = ""; - /** - * string reference_property = 1; - * @return The referenceProperty. - */ - public java.lang.String getReferenceProperty() { - java.lang.Object ref = referenceProperty_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - referenceProperty_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string reference_property = 1; - * @return The bytes for referenceProperty. - */ - public com.google.protobuf.ByteString - getReferencePropertyBytes() { - java.lang.Object ref = referenceProperty_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - referenceProperty_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string reference_property = 1; - * @param value The referenceProperty to set. - * @return This builder for chaining. - */ - public Builder setReferenceProperty( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - referenceProperty_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string reference_property = 1; - * @return This builder for chaining. - */ - public Builder clearReferenceProperty() { - referenceProperty_ = getDefaultInstance().getReferenceProperty(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string reference_property = 1; - * @param value The bytes for referenceProperty to set. - * @return This builder for chaining. - */ - public Builder setReferencePropertyBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - referenceProperty_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest properties_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> propertiesBuilder_; - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return Whether the properties field is set. - */ - public boolean hasProperties() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - * @return The properties. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest getProperties() { - if (propertiesBuilder_ == null) { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } else { - return propertiesBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - properties_ = value; - } else { - propertiesBuilder_.setMessage(value); - } - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public Builder setProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder builderForValue) { - if (propertiesBuilder_ == null) { - properties_ = builderForValue.build(); - } else { - propertiesBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public Builder mergeProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest value) { - if (propertiesBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0) && - properties_ != null && - properties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) { - getPropertiesBuilder().mergeFrom(value); - } else { - properties_ = value; - } - } else { - propertiesBuilder_.mergeFrom(value); - } - if (properties_ != null) { - bitField0_ |= 0x00000002; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public Builder clearProperties() { - bitField0_ = (bitField0_ & ~0x00000002); - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder getPropertiesBuilder() { - bitField0_ |= 0x00000002; - onChanged(); - return getPropertiesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { - if (propertiesBuilder_ != null) { - return propertiesBuilder_.getMessageOrBuilder(); - } else { - return properties_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; - } - } - /** - * .weaviate.v1.PropertiesRequest properties = 2; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> - getPropertiesFieldBuilder() { - if (propertiesBuilder_ == null) { - propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequestOrBuilder>( - getProperties(), - getParentForChildren(), - isClean()); - properties_ = null; - } - return propertiesBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest metadata_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder> metadataBuilder_; - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return Whether the metadata field is set. - */ - public boolean hasMetadata() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - * @return The metadata. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest getMetadata() { - if (metadataBuilder_ == null) { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } else { - return metadataBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest value) { - if (metadataBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - metadata_ = value; - } else { - metadataBuilder_.setMessage(value); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public Builder setMetadata( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder builderForValue) { - if (metadataBuilder_ == null) { - metadata_ = builderForValue.build(); - } else { - metadataBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest value) { - if (metadataBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0) && - metadata_ != null && - metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) { - getMetadataBuilder().mergeFrom(value); - } else { - metadata_ = value; - } - } else { - metadataBuilder_.mergeFrom(value); - } - if (metadata_ != null) { - bitField0_ |= 0x00000004; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public Builder clearMetadata() { - bitField0_ = (bitField0_ & ~0x00000004); - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder getMetadataBuilder() { - bitField0_ |= 0x00000004; - onChanged(); - return getMetadataFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { - if (metadataBuilder_ != null) { - return metadataBuilder_.getMessageOrBuilder(); - } else { - return metadata_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; - } - } - /** - * .weaviate.v1.MetadataRequest metadata = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder> - getMetadataFieldBuilder() { - if (metadataBuilder_ == null) { - metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequestOrBuilder>( - getMetadata(), - getParentForChildren(), - isClean()); - metadata_ = null; - } - return metadataBuilder_; - } - - private java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 4; - * @return The targetCollection. - */ - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string target_collection = 4; - * @return The bytes for targetCollection. - */ - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string target_collection = 4; - * @param value The targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - targetCollection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * string target_collection = 4; - * @return This builder for chaining. - */ - public Builder clearTargetCollection() { - targetCollection_ = getDefaultInstance().getTargetCollection(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - return this; - } - /** - * string target_collection = 4; - * @param value The bytes for targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - targetCollection_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.RefPropertiesRequest) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.RefPropertiesRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public RefPropertiesRequest parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface RerankOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.Rerank) - com.google.protobuf.MessageOrBuilder { - - /** - * string property = 1; - * @return The property. - */ - java.lang.String getProperty(); - /** - * string property = 1; - * @return The bytes for property. - */ - com.google.protobuf.ByteString - getPropertyBytes(); - - /** - * optional string query = 2; - * @return Whether the query field is set. - */ - boolean hasQuery(); - /** - * optional string query = 2; - * @return The query. - */ - java.lang.String getQuery(); - /** - * optional string query = 2; - * @return The bytes for query. - */ - com.google.protobuf.ByteString - getQueryBytes(); - } - /** - * Protobuf type {@code weaviate.v1.Rerank} - */ - public static final class Rerank extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.Rerank) - RerankOrBuilder { - private static final long serialVersionUID = 0L; - // Use Rerank.newBuilder() to construct. - private Rerank(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private Rerank() { - property_ = ""; - query_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new Rerank(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder.class); - } - - private int bitField0_; - public static final int PROPERTY_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object property_ = ""; - /** - * string property = 1; - * @return The property. - */ - @java.lang.Override - public java.lang.String getProperty() { - java.lang.Object ref = property_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - property_ = s; - return s; - } - } - /** - * string property = 1; - * @return The bytes for property. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getPropertyBytes() { - java.lang.Object ref = property_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - property_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int QUERY_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object query_ = ""; - /** - * optional string query = 2; - * @return Whether the query field is set. - */ - @java.lang.Override - public boolean hasQuery() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional string query = 2; - * @return The query. - */ - @java.lang.Override - public java.lang.String getQuery() { - java.lang.Object ref = query_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - query_ = s; - return s; - } - } - /** - * optional string query = 2; - * @return The bytes for query. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getQueryBytes() { - java.lang.Object ref = query_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - query_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(property_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, property_); - } - if (((bitField0_ & 0x00000001) != 0)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, query_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(property_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, property_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, query_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank) obj; - - if (!getProperty() - .equals(other.getProperty())) return false; - if (hasQuery() != other.hasQuery()) return false; - if (hasQuery()) { - if (!getQuery() - .equals(other.getQuery())) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + PROPERTY_FIELD_NUMBER; - hash = (53 * hash) + getProperty().hashCode(); - if (hasQuery()) { - hash = (37 * hash) + QUERY_FIELD_NUMBER; - hash = (53 * hash) + getQuery().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.Rerank} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.Rerank) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - property_ = ""; - query_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.property_ = property_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.query_ = query_; - to_bitField0_ |= 0x00000001; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank.getDefaultInstance()) return this; - if (!other.getProperty().isEmpty()) { - property_ = other.property_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (other.hasQuery()) { - query_ = other.query_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - property_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - query_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object property_ = ""; - /** - * string property = 1; - * @return The property. - */ - public java.lang.String getProperty() { - java.lang.Object ref = property_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - property_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string property = 1; - * @return The bytes for property. - */ - public com.google.protobuf.ByteString - getPropertyBytes() { - java.lang.Object ref = property_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - property_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string property = 1; - * @param value The property to set. - * @return This builder for chaining. - */ - public Builder setProperty( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - property_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string property = 1; - * @return This builder for chaining. - */ - public Builder clearProperty() { - property_ = getDefaultInstance().getProperty(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string property = 1; - * @param value The bytes for property to set. - * @return This builder for chaining. - */ - public Builder setPropertyBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - property_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private java.lang.Object query_ = ""; - /** - * optional string query = 2; - * @return Whether the query field is set. - */ - public boolean hasQuery() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional string query = 2; - * @return The query. - */ - public java.lang.String getQuery() { - java.lang.Object ref = query_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - query_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * optional string query = 2; - * @return The bytes for query. - */ - public com.google.protobuf.ByteString - getQueryBytes() { - java.lang.Object ref = query_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - query_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * optional string query = 2; - * @param value The query to set. - * @return This builder for chaining. - */ - public Builder setQuery( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - query_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * optional string query = 2; - * @return This builder for chaining. - */ - public Builder clearQuery() { - query_ = getDefaultInstance().getQuery(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * optional string query = 2; - * @param value The bytes for query to set. - * @return This builder for chaining. - */ - public Builder setQueryBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - query_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.Rerank) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.Rerank) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public Rerank parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.Rerank getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface SearchReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchReply) - com.google.protobuf.MessageOrBuilder { - - /** - * float took = 1; - * @return The took. - */ - float getTook(); - - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - java.util.List - getResultsList(); - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getResults(int index); - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - int getResultsCount(); - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - java.util.List - getResultsOrBuilderList(); - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( - int index); - - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return Whether the generativeGroupedResult field is set. - */ - @java.lang.Deprecated boolean hasGenerativeGroupedResult(); - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The generativeGroupedResult. - */ - @java.lang.Deprecated java.lang.String getGenerativeGroupedResult(); - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The bytes for generativeGroupedResult. - */ - @java.lang.Deprecated com.google.protobuf.ByteString - getGenerativeGroupedResultBytes(); - - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - java.util.List - getGroupByResultsList(); - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index); - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - int getGroupByResultsCount(); - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - java.util.List - getGroupByResultsOrBuilderList(); - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( - int index); - - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return Whether the generativeGroupedResults field is set. - */ - boolean hasGenerativeGroupedResults(); - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return The generativeGroupedResults. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults(); - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder(); - } - /** - * Protobuf type {@code weaviate.v1.SearchReply} - */ - public static final class SearchReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.SearchReply) - SearchReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use SearchReply.newBuilder() to construct. - private SearchReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SearchReply() { - results_ = java.util.Collections.emptyList(); - generativeGroupedResult_ = ""; - groupByResults_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SearchReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.Builder.class); - } - - private int bitField0_; - public static final int TOOK_FIELD_NUMBER = 1; - private float took_ = 0F; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - - public static final int RESULTS_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List results_; - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - @java.lang.Override - public java.util.List getResultsList() { - return results_; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - @java.lang.Override - public java.util.List - getResultsOrBuilderList() { - return results_; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - @java.lang.Override - public int getResultsCount() { - return results_.size(); - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getResults(int index) { - return results_.get(index); - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( - int index) { - return results_.get(index); - } - - public static final int GENERATIVE_GROUPED_RESULT_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object generativeGroupedResult_ = ""; - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return Whether the generativeGroupedResult field is set. - */ - @java.lang.Override - @java.lang.Deprecated public boolean hasGenerativeGroupedResult() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The generativeGroupedResult. - */ - @java.lang.Override - @java.lang.Deprecated public java.lang.String getGenerativeGroupedResult() { - java.lang.Object ref = generativeGroupedResult_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - generativeGroupedResult_ = s; - return s; - } - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The bytes for generativeGroupedResult. - */ - @java.lang.Override - @java.lang.Deprecated public com.google.protobuf.ByteString - getGenerativeGroupedResultBytes() { - java.lang.Object ref = generativeGroupedResult_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - generativeGroupedResult_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int GROUP_BY_RESULTS_FIELD_NUMBER = 4; - @SuppressWarnings("serial") - private java.util.List groupByResults_; - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - @java.lang.Override - public java.util.List getGroupByResultsList() { - return groupByResults_; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - @java.lang.Override - public java.util.List - getGroupByResultsOrBuilderList() { - return groupByResults_; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - @java.lang.Override - public int getGroupByResultsCount() { - return groupByResults_.size(); - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index) { - return groupByResults_.get(index); - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( - int index) { - return groupByResults_.get(index); - } - - public static final int GENERATIVE_GROUPED_RESULTS_FIELD_NUMBER = 5; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generativeGroupedResults_; - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return Whether the generativeGroupedResults field is set. - */ - @java.lang.Override - public boolean hasGenerativeGroupedResults() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return The generativeGroupedResults. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults() { - return generativeGroupedResults_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder() { - return generativeGroupedResults_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - output.writeFloat(1, took_); - } - for (int i = 0; i < results_.size(); i++) { - output.writeMessage(2, results_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, generativeGroupedResult_); - } - for (int i = 0; i < groupByResults_.size(); i++) { - output.writeMessage(4, groupByResults_.get(i)); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(5, getGenerativeGroupedResults()); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (java.lang.Float.floatToRawIntBits(took_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(1, took_); - } - for (int i = 0; i < results_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, results_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, generativeGroupedResult_); - } - for (int i = 0; i < groupByResults_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, groupByResults_.get(i)); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, getGenerativeGroupedResults()); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply) obj; - - if (java.lang.Float.floatToIntBits(getTook()) - != java.lang.Float.floatToIntBits( - other.getTook())) return false; - if (!getResultsList() - .equals(other.getResultsList())) return false; - if (hasGenerativeGroupedResult() != other.hasGenerativeGroupedResult()) return false; - if (hasGenerativeGroupedResult()) { - if (!getGenerativeGroupedResult() - .equals(other.getGenerativeGroupedResult())) return false; - } - if (!getGroupByResultsList() - .equals(other.getGroupByResultsList())) return false; - if (hasGenerativeGroupedResults() != other.hasGenerativeGroupedResults()) return false; - if (hasGenerativeGroupedResults()) { - if (!getGenerativeGroupedResults() - .equals(other.getGenerativeGroupedResults())) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + TOOK_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getTook()); - if (getResultsCount() > 0) { - hash = (37 * hash) + RESULTS_FIELD_NUMBER; - hash = (53 * hash) + getResultsList().hashCode(); - } - if (hasGenerativeGroupedResult()) { - hash = (37 * hash) + GENERATIVE_GROUPED_RESULT_FIELD_NUMBER; - hash = (53 * hash) + getGenerativeGroupedResult().hashCode(); - } - if (getGroupByResultsCount() > 0) { - hash = (37 * hash) + GROUP_BY_RESULTS_FIELD_NUMBER; - hash = (53 * hash) + getGroupByResultsList().hashCode(); - } - if (hasGenerativeGroupedResults()) { - hash = (37 * hash) + GENERATIVE_GROUPED_RESULTS_FIELD_NUMBER; - hash = (53 * hash) + getGenerativeGroupedResults().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.SearchReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getResultsFieldBuilder(); - getGroupByResultsFieldBuilder(); - getGenerativeGroupedResultsFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - took_ = 0F; - if (resultsBuilder_ == null) { - results_ = java.util.Collections.emptyList(); - } else { - results_ = null; - resultsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000002); - generativeGroupedResult_ = ""; - if (groupByResultsBuilder_ == null) { - groupByResults_ = java.util.Collections.emptyList(); - } else { - groupByResults_ = null; - groupByResultsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000008); - generativeGroupedResults_ = null; - if (generativeGroupedResultsBuilder_ != null) { - generativeGroupedResultsBuilder_.dispose(); - generativeGroupedResultsBuilder_ = null; - } - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply result) { - if (resultsBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0)) { - results_ = java.util.Collections.unmodifiableList(results_); - bitField0_ = (bitField0_ & ~0x00000002); - } - result.results_ = results_; - } else { - result.results_ = resultsBuilder_.build(); - } - if (groupByResultsBuilder_ == null) { - if (((bitField0_ & 0x00000008) != 0)) { - groupByResults_ = java.util.Collections.unmodifiableList(groupByResults_); - bitField0_ = (bitField0_ & ~0x00000008); - } - result.groupByResults_ = groupByResults_; - } else { - result.groupByResults_ = groupByResultsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.took_ = took_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000004) != 0)) { - result.generativeGroupedResult_ = generativeGroupedResult_; - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.generativeGroupedResults_ = generativeGroupedResultsBuilder_ == null - ? generativeGroupedResults_ - : generativeGroupedResultsBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply.getDefaultInstance()) return this; - if (other.getTook() != 0F) { - setTook(other.getTook()); - } - if (resultsBuilder_ == null) { - if (!other.results_.isEmpty()) { - if (results_.isEmpty()) { - results_ = other.results_; - bitField0_ = (bitField0_ & ~0x00000002); - } else { - ensureResultsIsMutable(); - results_.addAll(other.results_); - } - onChanged(); - } - } else { - if (!other.results_.isEmpty()) { - if (resultsBuilder_.isEmpty()) { - resultsBuilder_.dispose(); - resultsBuilder_ = null; - results_ = other.results_; - bitField0_ = (bitField0_ & ~0x00000002); - resultsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getResultsFieldBuilder() : null; - } else { - resultsBuilder_.addAllMessages(other.results_); - } - } - } - if (other.hasGenerativeGroupedResult()) { - generativeGroupedResult_ = other.generativeGroupedResult_; - bitField0_ |= 0x00000004; - onChanged(); - } - if (groupByResultsBuilder_ == null) { - if (!other.groupByResults_.isEmpty()) { - if (groupByResults_.isEmpty()) { - groupByResults_ = other.groupByResults_; - bitField0_ = (bitField0_ & ~0x00000008); - } else { - ensureGroupByResultsIsMutable(); - groupByResults_.addAll(other.groupByResults_); - } - onChanged(); - } - } else { - if (!other.groupByResults_.isEmpty()) { - if (groupByResultsBuilder_.isEmpty()) { - groupByResultsBuilder_.dispose(); - groupByResultsBuilder_ = null; - groupByResults_ = other.groupByResults_; - bitField0_ = (bitField0_ & ~0x00000008); - groupByResultsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getGroupByResultsFieldBuilder() : null; - } else { - groupByResultsBuilder_.addAllMessages(other.groupByResults_); - } - } - } - if (other.hasGenerativeGroupedResults()) { - mergeGenerativeGroupedResults(other.getGenerativeGroupedResults()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 13: { - took_ = input.readFloat(); - bitField0_ |= 0x00000001; - break; - } // case 13 - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.parser(), - extensionRegistry); - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - results_.add(m); - } else { - resultsBuilder_.addMessage(m); - } - break; - } // case 18 - case 26: { - generativeGroupedResult_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000004; - break; - } // case 26 - case 34: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.parser(), - extensionRegistry); - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - groupByResults_.add(m); - } else { - groupByResultsBuilder_.addMessage(m); - } - break; - } // case 34 - case 42: { - input.readMessage( - getGenerativeGroupedResultsFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000010; - break; - } // case 42 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private float took_ ; - /** - * float took = 1; - * @return The took. - */ - @java.lang.Override - public float getTook() { - return took_; - } - /** - * float took = 1; - * @param value The took to set. - * @return This builder for chaining. - */ - public Builder setTook(float value) { - - took_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * float took = 1; - * @return This builder for chaining. - */ - public Builder clearTook() { - bitField0_ = (bitField0_ & ~0x00000001); - took_ = 0F; - onChanged(); - return this; - } - - private java.util.List results_ = - java.util.Collections.emptyList(); - private void ensureResultsIsMutable() { - if (!((bitField0_ & 0x00000002) != 0)) { - results_ = new java.util.ArrayList(results_); - bitField0_ |= 0x00000002; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder> resultsBuilder_; - - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public java.util.List getResultsList() { - if (resultsBuilder_ == null) { - return java.util.Collections.unmodifiableList(results_); - } else { - return resultsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public int getResultsCount() { - if (resultsBuilder_ == null) { - return results_.size(); - } else { - return resultsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getResults(int index) { - if (resultsBuilder_ == null) { - return results_.get(index); - } else { - return resultsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder setResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (resultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureResultsIsMutable(); - results_.set(index, value); - onChanged(); - } else { - resultsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder setResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - results_.set(index, builderForValue.build()); - onChanged(); - } else { - resultsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder addResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (resultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureResultsIsMutable(); - results_.add(value); - onChanged(); - } else { - resultsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder addResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (resultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureResultsIsMutable(); - results_.add(index, value); - onChanged(); - } else { - resultsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder addResults( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - results_.add(builderForValue.build()); - onChanged(); - } else { - resultsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder addResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - results_.add(index, builderForValue.build()); - onChanged(); - } else { - resultsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder addAllResults( - java.lang.Iterable values) { - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, results_); - onChanged(); - } else { - resultsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder clearResults() { - if (resultsBuilder_ == null) { - results_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - } else { - resultsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public Builder removeResults(int index) { - if (resultsBuilder_ == null) { - ensureResultsIsMutable(); - results_.remove(index); - onChanged(); - } else { - resultsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder getResultsBuilder( - int index) { - return getResultsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( - int index) { - if (resultsBuilder_ == null) { - return results_.get(index); } else { - return resultsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public java.util.List - getResultsOrBuilderList() { - if (resultsBuilder_ != null) { - return resultsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(results_); - } - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder addResultsBuilder() { - return getResultsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder addResultsBuilder( - int index) { - return getResultsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.SearchResult results = 2; - */ - public java.util.List - getResultsBuilderList() { - return getResultsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder> - getResultsFieldBuilder() { - if (resultsBuilder_ == null) { - resultsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder>( - results_, - ((bitField0_ & 0x00000002) != 0), - getParentForChildren(), - isClean()); - results_ = null; - } - return resultsBuilder_; - } - - private java.lang.Object generativeGroupedResult_ = ""; - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return Whether the generativeGroupedResult field is set. - */ - @java.lang.Deprecated public boolean hasGenerativeGroupedResult() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The generativeGroupedResult. - */ - @java.lang.Deprecated public java.lang.String getGenerativeGroupedResult() { - java.lang.Object ref = generativeGroupedResult_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - generativeGroupedResult_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return The bytes for generativeGroupedResult. - */ - @java.lang.Deprecated public com.google.protobuf.ByteString - getGenerativeGroupedResultBytes() { - java.lang.Object ref = generativeGroupedResult_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - generativeGroupedResult_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @param value The generativeGroupedResult to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setGenerativeGroupedResult( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - generativeGroupedResult_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearGenerativeGroupedResult() { - generativeGroupedResult_ = getDefaultInstance().getGenerativeGroupedResult(); - bitField0_ = (bitField0_ & ~0x00000004); - onChanged(); - return this; - } - /** - * optional string generative_grouped_result = 3 [deprecated = true]; - * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. - * See v1/search_get.proto;l=115 - * @param value The bytes for generativeGroupedResult to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setGenerativeGroupedResultBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - generativeGroupedResult_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - - private java.util.List groupByResults_ = - java.util.Collections.emptyList(); - private void ensureGroupByResultsIsMutable() { - if (!((bitField0_ & 0x00000008) != 0)) { - groupByResults_ = new java.util.ArrayList(groupByResults_); - bitField0_ |= 0x00000008; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder> groupByResultsBuilder_; - - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public java.util.List getGroupByResultsList() { - if (groupByResultsBuilder_ == null) { - return java.util.Collections.unmodifiableList(groupByResults_); - } else { - return groupByResultsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public int getGroupByResultsCount() { - if (groupByResultsBuilder_ == null) { - return groupByResults_.size(); - } else { - return groupByResultsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index) { - if (groupByResultsBuilder_ == null) { - return groupByResults_.get(index); - } else { - return groupByResultsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder setGroupByResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult value) { - if (groupByResultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureGroupByResultsIsMutable(); - groupByResults_.set(index, value); - onChanged(); - } else { - groupByResultsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder setGroupByResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - groupByResults_.set(index, builderForValue.build()); - onChanged(); - } else { - groupByResultsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder addGroupByResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult value) { - if (groupByResultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureGroupByResultsIsMutable(); - groupByResults_.add(value); - onChanged(); - } else { - groupByResultsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder addGroupByResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult value) { - if (groupByResultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureGroupByResultsIsMutable(); - groupByResults_.add(index, value); - onChanged(); - } else { - groupByResultsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder addGroupByResults( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - groupByResults_.add(builderForValue.build()); - onChanged(); - } else { - groupByResultsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder addGroupByResults( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - groupByResults_.add(index, builderForValue.build()); - onChanged(); - } else { - groupByResultsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder addAllGroupByResults( - java.lang.Iterable values) { - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, groupByResults_); - onChanged(); - } else { - groupByResultsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder clearGroupByResults() { - if (groupByResultsBuilder_ == null) { - groupByResults_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000008); - onChanged(); - } else { - groupByResultsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public Builder removeGroupByResults(int index) { - if (groupByResultsBuilder_ == null) { - ensureGroupByResultsIsMutable(); - groupByResults_.remove(index); - onChanged(); - } else { - groupByResultsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder getGroupByResultsBuilder( - int index) { - return getGroupByResultsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( - int index) { - if (groupByResultsBuilder_ == null) { - return groupByResults_.get(index); } else { - return groupByResultsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public java.util.List - getGroupByResultsOrBuilderList() { - if (groupByResultsBuilder_ != null) { - return groupByResultsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(groupByResults_); - } - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder addGroupByResultsBuilder() { - return getGroupByResultsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder addGroupByResultsBuilder( - int index) { - return getGroupByResultsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.GroupByResult group_by_results = 4; - */ - public java.util.List - getGroupByResultsBuilderList() { - return getGroupByResultsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder> - getGroupByResultsFieldBuilder() { - if (groupByResultsBuilder_ == null) { - groupByResultsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder>( - groupByResults_, - ((bitField0_ & 0x00000008) != 0), - getParentForChildren(), - isClean()); - groupByResults_ = null; - } - return groupByResultsBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generativeGroupedResults_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeGroupedResultsBuilder_; - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return Whether the generativeGroupedResults field is set. - */ - public boolean hasGenerativeGroupedResults() { - return ((bitField0_ & 0x00000010) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - * @return The generativeGroupedResults. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults() { - if (generativeGroupedResultsBuilder_ == null) { - return generativeGroupedResults_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; - } else { - return generativeGroupedResultsBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public Builder setGenerativeGroupedResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeGroupedResultsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - generativeGroupedResults_ = value; - } else { - generativeGroupedResultsBuilder_.setMessage(value); - } - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public Builder setGenerativeGroupedResults( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { - if (generativeGroupedResultsBuilder_ == null) { - generativeGroupedResults_ = builderForValue.build(); - } else { - generativeGroupedResultsBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public Builder mergeGenerativeGroupedResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeGroupedResultsBuilder_ == null) { - if (((bitField0_ & 0x00000010) != 0) && - generativeGroupedResults_ != null && - generativeGroupedResults_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { - getGenerativeGroupedResultsBuilder().mergeFrom(value); - } else { - generativeGroupedResults_ = value; - } - } else { - generativeGroupedResultsBuilder_.mergeFrom(value); - } - if (generativeGroupedResults_ != null) { - bitField0_ |= 0x00000010; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public Builder clearGenerativeGroupedResults() { - bitField0_ = (bitField0_ & ~0x00000010); - generativeGroupedResults_ = null; - if (generativeGroupedResultsBuilder_ != null) { - generativeGroupedResultsBuilder_.dispose(); - generativeGroupedResultsBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeGroupedResultsBuilder() { - bitField0_ |= 0x00000010; - onChanged(); - return getGenerativeGroupedResultsFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder() { - if (generativeGroupedResultsBuilder_ != null) { - return generativeGroupedResultsBuilder_.getMessageOrBuilder(); - } else { - return generativeGroupedResults_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; - } - } - /** - * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> - getGenerativeGroupedResultsFieldBuilder() { - if (generativeGroupedResultsBuilder_ == null) { - generativeGroupedResultsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder>( - getGenerativeGroupedResults(), - getParentForChildren(), - isClean()); - generativeGroupedResults_ = null; - } - return generativeGroupedResultsBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchReply) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.SearchReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SearchReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface RerankReplyOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.RerankReply) - com.google.protobuf.MessageOrBuilder { - - /** - * double score = 1; - * @return The score. - */ - double getScore(); - } - /** - * Protobuf type {@code weaviate.v1.RerankReply} - */ - public static final class RerankReply extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.RerankReply) - RerankReplyOrBuilder { - private static final long serialVersionUID = 0L; - // Use RerankReply.newBuilder() to construct. - private RerankReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private RerankReply() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new RerankReply(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder.class); - } - - public static final int SCORE_FIELD_NUMBER = 1; - private double score_ = 0D; - /** - * double score = 1; - * @return The score. - */ - @java.lang.Override - public double getScore() { - return score_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (java.lang.Double.doubleToRawLongBits(score_) != 0) { - output.writeDouble(1, score_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (java.lang.Double.doubleToRawLongBits(score_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeDoubleSize(1, score_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply) obj; - - if (java.lang.Double.doubleToLongBits(getScore()) - != java.lang.Double.doubleToLongBits( - other.getScore())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + SCORE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - java.lang.Double.doubleToLongBits(getScore())); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.RerankReply} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.RerankReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - score_ = 0D; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.score_ = score_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance()) return this; - if (other.getScore() != 0D) { - setScore(other.getScore()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 9: { - score_ = input.readDouble(); - bitField0_ |= 0x00000001; - break; - } // case 9 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private double score_ ; - /** - * double score = 1; - * @return The score. - */ - @java.lang.Override - public double getScore() { - return score_; - } - /** - * double score = 1; - * @param value The score to set. - * @return This builder for chaining. - */ - public Builder setScore(double value) { - - score_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * double score = 1; - * @return This builder for chaining. - */ - public Builder clearScore() { - bitField0_ = (bitField0_ & ~0x00000001); - score_ = 0D; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.RerankReply) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.RerankReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public RerankReply parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface GroupByResultOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.GroupByResult) - com.google.protobuf.MessageOrBuilder { - - /** - * string name = 1; - * @return The name. - */ - java.lang.String getName(); - /** - * string name = 1; - * @return The bytes for name. - */ - com.google.protobuf.ByteString - getNameBytes(); - - /** - * float min_distance = 2; - * @return The minDistance. - */ - float getMinDistance(); - - /** - * float max_distance = 3; - * @return The maxDistance. - */ - float getMaxDistance(); - - /** - * int64 number_of_objects = 4; - * @return The numberOfObjects. - */ - long getNumberOfObjects(); - - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - java.util.List - getObjectsList(); - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getObjects(int index); - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - int getObjectsCount(); - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - java.util.List - getObjectsOrBuilderList(); - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( - int index); - - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return Whether the rerank field is set. - */ - boolean hasRerank(); - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return The rerank. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getRerank(); - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder(); - - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return Whether the generative field is set. - */ - @java.lang.Deprecated boolean hasGenerative(); - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return The generative. - */ - @java.lang.Deprecated io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getGenerative(); - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder(); - - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return Whether the generativeResult field is set. - */ - boolean hasGenerativeResult(); - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return The generativeResult. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeResult(); - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder(); - } - /** - * Protobuf type {@code weaviate.v1.GroupByResult} - */ - public static final class GroupByResult extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.GroupByResult) - GroupByResultOrBuilder { - private static final long serialVersionUID = 0L; - // Use GroupByResult.newBuilder() to construct. - private GroupByResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private GroupByResult() { - name_ = ""; - objects_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new GroupByResult(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder.class); - } - - private int bitField0_; - public static final int NAME_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object name_ = ""; - /** - * string name = 1; - * @return The name. - */ - @java.lang.Override - public java.lang.String getName() { - java.lang.Object ref = name_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - name_ = s; - return s; - } - } - /** - * string name = 1; - * @return The bytes for name. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getNameBytes() { - java.lang.Object ref = name_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - name_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int MIN_DISTANCE_FIELD_NUMBER = 2; - private float minDistance_ = 0F; - /** - * float min_distance = 2; - * @return The minDistance. - */ - @java.lang.Override - public float getMinDistance() { - return minDistance_; - } - - public static final int MAX_DISTANCE_FIELD_NUMBER = 3; - private float maxDistance_ = 0F; - /** - * float max_distance = 3; - * @return The maxDistance. - */ - @java.lang.Override - public float getMaxDistance() { - return maxDistance_; - } - - public static final int NUMBER_OF_OBJECTS_FIELD_NUMBER = 4; - private long numberOfObjects_ = 0L; - /** - * int64 number_of_objects = 4; - * @return The numberOfObjects. - */ - @java.lang.Override - public long getNumberOfObjects() { - return numberOfObjects_; - } - - public static final int OBJECTS_FIELD_NUMBER = 5; - @SuppressWarnings("serial") - private java.util.List objects_; - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - @java.lang.Override - public java.util.List getObjectsList() { - return objects_; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - @java.lang.Override - public java.util.List - getObjectsOrBuilderList() { - return objects_; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - @java.lang.Override - public int getObjectsCount() { - return objects_.size(); - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getObjects(int index) { - return objects_.get(index); - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( - int index) { - return objects_.get(index); - } - - public static final int RERANK_FIELD_NUMBER = 6; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply rerank_; - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return Whether the rerank field is set. - */ - @java.lang.Override - public boolean hasRerank() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return The rerank. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getRerank() { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder() { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; - } - - public static final int GENERATIVE_FIELD_NUMBER = 7; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply generative_; - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return Whether the generative field is set. - */ - @java.lang.Override - @java.lang.Deprecated public boolean hasGenerative() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return The generative. - */ - @java.lang.Override - @java.lang.Deprecated public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getGenerative() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Override - @java.lang.Deprecated public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; - } - - public static final int GENERATIVE_RESULT_FIELD_NUMBER = 8; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generativeResult_; - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return Whether the generativeResult field is set. - */ - @java.lang.Override - public boolean hasGenerativeResult() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return The generativeResult. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeResult() { - return generativeResult_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder() { - return generativeResult_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); - } - if (java.lang.Float.floatToRawIntBits(minDistance_) != 0) { - output.writeFloat(2, minDistance_); - } - if (java.lang.Float.floatToRawIntBits(maxDistance_) != 0) { - output.writeFloat(3, maxDistance_); - } - if (numberOfObjects_ != 0L) { - output.writeInt64(4, numberOfObjects_); - } - for (int i = 0; i < objects_.size(); i++) { - output.writeMessage(5, objects_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(6, getRerank()); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(7, getGenerative()); - } - if (((bitField0_ & 0x00000004) != 0)) { - output.writeMessage(8, getGenerativeResult()); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); - } - if (java.lang.Float.floatToRawIntBits(minDistance_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(2, minDistance_); - } - if (java.lang.Float.floatToRawIntBits(maxDistance_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(3, maxDistance_); - } - if (numberOfObjects_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(4, numberOfObjects_); - } - for (int i = 0; i < objects_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(5, objects_.get(i)); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(6, getRerank()); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(7, getGenerative()); - } - if (((bitField0_ & 0x00000004) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(8, getGenerativeResult()); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult) obj; - - if (!getName() - .equals(other.getName())) return false; - if (java.lang.Float.floatToIntBits(getMinDistance()) - != java.lang.Float.floatToIntBits( - other.getMinDistance())) return false; - if (java.lang.Float.floatToIntBits(getMaxDistance()) - != java.lang.Float.floatToIntBits( - other.getMaxDistance())) return false; - if (getNumberOfObjects() - != other.getNumberOfObjects()) return false; - if (!getObjectsList() - .equals(other.getObjectsList())) return false; - if (hasRerank() != other.hasRerank()) return false; - if (hasRerank()) { - if (!getRerank() - .equals(other.getRerank())) return false; - } - if (hasGenerative() != other.hasGenerative()) return false; - if (hasGenerative()) { - if (!getGenerative() - .equals(other.getGenerative())) return false; - } - if (hasGenerativeResult() != other.hasGenerativeResult()) return false; - if (hasGenerativeResult()) { - if (!getGenerativeResult() - .equals(other.getGenerativeResult())) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + NAME_FIELD_NUMBER; - hash = (53 * hash) + getName().hashCode(); - hash = (37 * hash) + MIN_DISTANCE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getMinDistance()); - hash = (37 * hash) + MAX_DISTANCE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getMaxDistance()); - hash = (37 * hash) + NUMBER_OF_OBJECTS_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getNumberOfObjects()); - if (getObjectsCount() > 0) { - hash = (37 * hash) + OBJECTS_FIELD_NUMBER; - hash = (53 * hash) + getObjectsList().hashCode(); - } - if (hasRerank()) { - hash = (37 * hash) + RERANK_FIELD_NUMBER; - hash = (53 * hash) + getRerank().hashCode(); - } - if (hasGenerative()) { - hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; - hash = (53 * hash) + getGenerative().hashCode(); - } - if (hasGenerativeResult()) { - hash = (37 * hash) + GENERATIVE_RESULT_FIELD_NUMBER; - hash = (53 * hash) + getGenerativeResult().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.GroupByResult} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.GroupByResult) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResultOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getObjectsFieldBuilder(); - getRerankFieldBuilder(); - getGenerativeFieldBuilder(); - getGenerativeResultFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - name_ = ""; - minDistance_ = 0F; - maxDistance_ = 0F; - numberOfObjects_ = 0L; - if (objectsBuilder_ == null) { - objects_ = java.util.Collections.emptyList(); - } else { - objects_ = null; - objectsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000010); - rerank_ = null; - if (rerankBuilder_ != null) { - rerankBuilder_.dispose(); - rerankBuilder_ = null; - } - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - generativeResult_ = null; - if (generativeResultBuilder_ != null) { - generativeResultBuilder_.dispose(); - generativeResultBuilder_ = null; - } - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult result) { - if (objectsBuilder_ == null) { - if (((bitField0_ & 0x00000010) != 0)) { - objects_ = java.util.Collections.unmodifiableList(objects_); - bitField0_ = (bitField0_ & ~0x00000010); - } - result.objects_ = objects_; - } else { - result.objects_ = objectsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.name_ = name_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.minDistance_ = minDistance_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.maxDistance_ = maxDistance_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.numberOfObjects_ = numberOfObjects_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000020) != 0)) { - result.rerank_ = rerankBuilder_ == null - ? rerank_ - : rerankBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000040) != 0)) { - result.generative_ = generativeBuilder_ == null - ? generative_ - : generativeBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000080) != 0)) { - result.generativeResult_ = generativeResultBuilder_ == null - ? generativeResult_ - : generativeResultBuilder_.build(); - to_bitField0_ |= 0x00000004; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()) return this; - if (!other.getName().isEmpty()) { - name_ = other.name_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (other.getMinDistance() != 0F) { - setMinDistance(other.getMinDistance()); - } - if (other.getMaxDistance() != 0F) { - setMaxDistance(other.getMaxDistance()); - } - if (other.getNumberOfObjects() != 0L) { - setNumberOfObjects(other.getNumberOfObjects()); - } - if (objectsBuilder_ == null) { - if (!other.objects_.isEmpty()) { - if (objects_.isEmpty()) { - objects_ = other.objects_; - bitField0_ = (bitField0_ & ~0x00000010); - } else { - ensureObjectsIsMutable(); - objects_.addAll(other.objects_); - } - onChanged(); - } - } else { - if (!other.objects_.isEmpty()) { - if (objectsBuilder_.isEmpty()) { - objectsBuilder_.dispose(); - objectsBuilder_ = null; - objects_ = other.objects_; - bitField0_ = (bitField0_ & ~0x00000010); - objectsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getObjectsFieldBuilder() : null; - } else { - objectsBuilder_.addAllMessages(other.objects_); - } - } - } - if (other.hasRerank()) { - mergeRerank(other.getRerank()); - } - if (other.hasGenerative()) { - mergeGenerative(other.getGenerative()); - } - if (other.hasGenerativeResult()) { - mergeGenerativeResult(other.getGenerativeResult()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - name_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 21: { - minDistance_ = input.readFloat(); - bitField0_ |= 0x00000002; - break; - } // case 21 - case 29: { - maxDistance_ = input.readFloat(); - bitField0_ |= 0x00000004; - break; - } // case 29 - case 32: { - numberOfObjects_ = input.readInt64(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 42: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.parser(), - extensionRegistry); - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(m); - } else { - objectsBuilder_.addMessage(m); - } - break; - } // case 42 - case 50: { - input.readMessage( - getRerankFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000020; - break; - } // case 50 - case 58: { - input.readMessage( - getGenerativeFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000040; - break; - } // case 58 - case 66: { - input.readMessage( - getGenerativeResultFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000080; - break; - } // case 66 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object name_ = ""; - /** - * string name = 1; - * @return The name. - */ - public java.lang.String getName() { - java.lang.Object ref = name_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - name_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string name = 1; - * @return The bytes for name. - */ - public com.google.protobuf.ByteString - getNameBytes() { - java.lang.Object ref = name_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - name_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string name = 1; - * @param value The name to set. - * @return This builder for chaining. - */ - public Builder setName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - name_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string name = 1; - * @return This builder for chaining. - */ - public Builder clearName() { - name_ = getDefaultInstance().getName(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string name = 1; - * @param value The bytes for name to set. - * @return This builder for chaining. - */ - public Builder setNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - name_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private float minDistance_ ; - /** - * float min_distance = 2; - * @return The minDistance. - */ - @java.lang.Override - public float getMinDistance() { - return minDistance_; - } - /** - * float min_distance = 2; - * @param value The minDistance to set. - * @return This builder for chaining. - */ - public Builder setMinDistance(float value) { - - minDistance_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * float min_distance = 2; - * @return This builder for chaining. - */ - public Builder clearMinDistance() { - bitField0_ = (bitField0_ & ~0x00000002); - minDistance_ = 0F; - onChanged(); - return this; - } - - private float maxDistance_ ; - /** - * float max_distance = 3; - * @return The maxDistance. - */ - @java.lang.Override - public float getMaxDistance() { - return maxDistance_; - } - /** - * float max_distance = 3; - * @param value The maxDistance to set. - * @return This builder for chaining. - */ - public Builder setMaxDistance(float value) { - - maxDistance_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * float max_distance = 3; - * @return This builder for chaining. - */ - public Builder clearMaxDistance() { - bitField0_ = (bitField0_ & ~0x00000004); - maxDistance_ = 0F; - onChanged(); - return this; - } - - private long numberOfObjects_ ; - /** - * int64 number_of_objects = 4; - * @return The numberOfObjects. - */ - @java.lang.Override - public long getNumberOfObjects() { - return numberOfObjects_; - } - /** - * int64 number_of_objects = 4; - * @param value The numberOfObjects to set. - * @return This builder for chaining. - */ - public Builder setNumberOfObjects(long value) { - - numberOfObjects_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * int64 number_of_objects = 4; - * @return This builder for chaining. - */ - public Builder clearNumberOfObjects() { - bitField0_ = (bitField0_ & ~0x00000008); - numberOfObjects_ = 0L; - onChanged(); - return this; - } - - private java.util.List objects_ = - java.util.Collections.emptyList(); - private void ensureObjectsIsMutable() { - if (!((bitField0_ & 0x00000010) != 0)) { - objects_ = new java.util.ArrayList(objects_); - bitField0_ |= 0x00000010; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder> objectsBuilder_; - - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public java.util.List getObjectsList() { - if (objectsBuilder_ == null) { - return java.util.Collections.unmodifiableList(objects_); - } else { - return objectsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public int getObjectsCount() { - if (objectsBuilder_ == null) { - return objects_.size(); - } else { - return objectsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getObjects(int index) { - if (objectsBuilder_ == null) { - return objects_.get(index); - } else { - return objectsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.set(index, value); - onChanged(); - } else { - objectsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.set(index, builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder addObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.add(value); - onChanged(); - } else { - objectsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult value) { - if (objectsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureObjectsIsMutable(); - objects_.add(index, value); - onChanged(); - } else { - objectsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder addObjects( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.add(index, builderForValue.build()); - onChanged(); - } else { - objectsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder addAllObjects( - java.lang.Iterable values) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, objects_); - onChanged(); - } else { - objectsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder clearObjects() { - if (objectsBuilder_ == null) { - objects_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000010); - onChanged(); - } else { - objectsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public Builder removeObjects(int index) { - if (objectsBuilder_ == null) { - ensureObjectsIsMutable(); - objects_.remove(index); - onChanged(); - } else { - objectsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder getObjectsBuilder( - int index) { - return getObjectsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( - int index) { - if (objectsBuilder_ == null) { - return objects_.get(index); } else { - return objectsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public java.util.List - getObjectsOrBuilderList() { - if (objectsBuilder_ != null) { - return objectsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(objects_); - } - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder addObjectsBuilder() { - return getObjectsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder addObjectsBuilder( - int index) { - return getObjectsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.SearchResult objects = 5; - */ - public java.util.List - getObjectsBuilderList() { - return getObjectsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder> - getObjectsFieldBuilder() { - if (objectsBuilder_ == null) { - objectsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder>( - objects_, - ((bitField0_ & 0x00000010) != 0), - getParentForChildren(), - isClean()); - objects_ = null; - } - return objectsBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply rerank_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder> rerankBuilder_; - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return Whether the rerank field is set. - */ - public boolean hasRerank() { - return ((bitField0_ & 0x00000020) != 0); - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - * @return The rerank. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply getRerank() { - if (rerankBuilder_ == null) { - return rerank_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; - } else { - return rerankBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public Builder setRerank(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply value) { - if (rerankBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - rerank_ = value; - } else { - rerankBuilder_.setMessage(value); - } - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public Builder setRerank( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder builderForValue) { - if (rerankBuilder_ == null) { - rerank_ = builderForValue.build(); - } else { - rerankBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public Builder mergeRerank(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply value) { - if (rerankBuilder_ == null) { - if (((bitField0_ & 0x00000020) != 0) && - rerank_ != null && - rerank_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance()) { - getRerankBuilder().mergeFrom(value); - } else { - rerank_ = value; - } - } else { - rerankBuilder_.mergeFrom(value); - } - if (rerank_ != null) { - bitField0_ |= 0x00000020; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public Builder clearRerank() { - bitField0_ = (bitField0_ & ~0x00000020); - rerank_ = null; - if (rerankBuilder_ != null) { - rerankBuilder_.dispose(); - rerankBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder getRerankBuilder() { - bitField0_ |= 0x00000020; - onChanged(); - return getRerankFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder() { - if (rerankBuilder_ != null) { - return rerankBuilder_.getMessageOrBuilder(); - } else { - return rerank_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; - } - } - /** - * optional .weaviate.v1.RerankReply rerank = 6; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder> - getRerankFieldBuilder() { - if (rerankBuilder_ == null) { - rerankBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RerankReplyOrBuilder>( - getRerank(), - getParentForChildren(), - isClean()); - rerank_ = null; - } - return rerankBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply generative_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder> generativeBuilder_; - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return Whether the generative field is set. - */ - @java.lang.Deprecated public boolean hasGenerative() { - return ((bitField0_ & 0x00000040) != 0); - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - * @deprecated weaviate.v1.GroupByResult.generative is deprecated. - * See v1/search_get.proto;l=131 - * @return The generative. - */ - @java.lang.Deprecated public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getGenerative() { - if (generativeBuilder_ == null) { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; - } else { - return generativeBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public Builder setGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply value) { - if (generativeBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - generative_ = value; - } else { - generativeBuilder_.setMessage(value); - } - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public Builder setGenerative( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) { - if (generativeBuilder_ == null) { - generative_ = builderForValue.build(); - } else { - generativeBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public Builder mergeGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply value) { - if (generativeBuilder_ == null) { - if (((bitField0_ & 0x00000040) != 0) && - generative_ != null && - generative_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance()) { - getGenerativeBuilder().mergeFrom(value); - } else { - generative_ = value; - } - } else { - generativeBuilder_.mergeFrom(value); - } - if (generative_ != null) { - bitField0_ |= 0x00000040; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public Builder clearGenerative() { - bitField0_ = (bitField0_ & ~0x00000040); - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder getGenerativeBuilder() { - bitField0_ |= 0x00000040; - onChanged(); - return getGenerativeFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - @java.lang.Deprecated public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder() { - if (generativeBuilder_ != null) { - return generativeBuilder_.getMessageOrBuilder(); - } else { - return generative_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; - } - } - /** - * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder> - getGenerativeFieldBuilder() { - if (generativeBuilder_ == null) { - generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder>( - getGenerative(), - getParentForChildren(), - isClean()); - generative_ = null; - } - return generativeBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generativeResult_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeResultBuilder_; - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return Whether the generativeResult field is set. - */ - public boolean hasGenerativeResult() { - return ((bitField0_ & 0x00000080) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - * @return The generativeResult. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerativeResult() { - if (generativeResultBuilder_ == null) { - return generativeResult_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; - } else { - return generativeResultBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public Builder setGenerativeResult(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeResultBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - generativeResult_ = value; - } else { - generativeResultBuilder_.setMessage(value); - } - bitField0_ |= 0x00000080; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public Builder setGenerativeResult( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { - if (generativeResultBuilder_ == null) { - generativeResult_ = builderForValue.build(); - } else { - generativeResultBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000080; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public Builder mergeGenerativeResult(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeResultBuilder_ == null) { - if (((bitField0_ & 0x00000080) != 0) && - generativeResult_ != null && - generativeResult_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { - getGenerativeResultBuilder().mergeFrom(value); - } else { - generativeResult_ = value; - } - } else { - generativeResultBuilder_.mergeFrom(value); - } - if (generativeResult_ != null) { - bitField0_ |= 0x00000080; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public Builder clearGenerativeResult() { - bitField0_ = (bitField0_ & ~0x00000080); - generativeResult_ = null; - if (generativeResultBuilder_ != null) { - generativeResultBuilder_.dispose(); - generativeResultBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeResultBuilder() { - bitField0_ |= 0x00000080; - onChanged(); - return getGenerativeResultFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder() { - if (generativeResultBuilder_ != null) { - return generativeResultBuilder_.getMessageOrBuilder(); - } else { - return generativeResult_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; - } - } - /** - * optional .weaviate.v1.GenerativeResult generative_result = 8; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> - getGenerativeResultFieldBuilder() { - if (generativeResultBuilder_ == null) { - generativeResultBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder>( - getGenerativeResult(), - getParentForChildren(), - isClean()); - generativeResult_ = null; - } - return generativeResultBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.GroupByResult) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.GroupByResult) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public GroupByResult parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.GroupByResult getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface SearchResultOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchResult) - com.google.protobuf.MessageOrBuilder { - - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return Whether the properties field is set. - */ - boolean hasProperties(); - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return The properties. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties(); - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder(); - - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return Whether the metadata field is set. - */ - boolean hasMetadata(); - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return The metadata. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata(); - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder(); - - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return Whether the generative field is set. - */ - boolean hasGenerative(); - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return The generative. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerative(); - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder(); - } - /** - * Protobuf type {@code weaviate.v1.SearchResult} - */ - public static final class SearchResult extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.SearchResult) - SearchResultOrBuilder { - private static final long serialVersionUID = 0L; - // Use SearchResult.newBuilder() to construct. - private SearchResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private SearchResult() { - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new SearchResult(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder.class); - } - - private int bitField0_; - public static final int PROPERTIES_FIELD_NUMBER = 1; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult properties_; - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return Whether the properties field is set. - */ - @java.lang.Override - public boolean hasProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return The properties. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder() { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; - } - - public static final int METADATA_FIELD_NUMBER = 2; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult metadata_; - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return Whether the metadata field is set. - */ - @java.lang.Override - public boolean hasMetadata() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return The metadata. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - - public static final int GENERATIVE_FIELD_NUMBER = 3; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generative_; - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return Whether the generative field is set. - */ - @java.lang.Override - public boolean hasGenerative() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return The generative. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerative() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder() { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(1, getProperties()); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(2, getMetadata()); - } - if (((bitField0_ & 0x00000004) != 0)) { - output.writeMessage(3, getGenerative()); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, getProperties()); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, getMetadata()); - } - if (((bitField0_ & 0x00000004) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(3, getGenerative()); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult) obj; - - if (hasProperties() != other.hasProperties()) return false; - if (hasProperties()) { - if (!getProperties() - .equals(other.getProperties())) return false; - } - if (hasMetadata() != other.hasMetadata()) return false; - if (hasMetadata()) { - if (!getMetadata() - .equals(other.getMetadata())) return false; - } - if (hasGenerative() != other.hasGenerative()) return false; - if (hasGenerative()) { - if (!getGenerative() - .equals(other.getGenerative())) return false; - } - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (hasProperties()) { - hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getProperties().hashCode(); - } - if (hasMetadata()) { - hash = (37 * hash) + METADATA_FIELD_NUMBER; - hash = (53 * hash) + getMetadata().hashCode(); - } - if (hasGenerative()) { - hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; - hash = (53 * hash) + getGenerative().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.SearchResult} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchResult) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResultOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getPropertiesFieldBuilder(); - getMetadataFieldBuilder(); - getGenerativeFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult(this); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult result) { - int from_bitField0_ = bitField0_; - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.properties_ = propertiesBuilder_ == null - ? properties_ - : propertiesBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - result.metadata_ = metadataBuilder_ == null - ? metadata_ - : metadataBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.generative_ = generativeBuilder_ == null - ? generative_ - : generativeBuilder_.build(); - to_bitField0_ |= 0x00000004; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()) return this; - if (other.hasProperties()) { - mergeProperties(other.getProperties()); - } - if (other.hasMetadata()) { - mergeMetadata(other.getMetadata()); - } - if (other.hasGenerative()) { - mergeGenerative(other.getGenerative()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - input.readMessage( - getPropertiesFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 18: { - input.readMessage( - getMetadataFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000002; - break; - } // case 18 - case 26: { - input.readMessage( - getGenerativeFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000004; - break; - } // case 26 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult properties_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder> propertiesBuilder_; - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return Whether the properties field is set. - */ - public boolean hasProperties() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - * @return The properties. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties() { - if (propertiesBuilder_ == null) { - return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; - } else { - return propertiesBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - properties_ = value; - } else { - propertiesBuilder_.setMessage(value); - } - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder setProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { - if (propertiesBuilder_ == null) { - properties_ = builderForValue.build(); - } else { - propertiesBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder mergeProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult value) { - if (propertiesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0) && - properties_ != null && - properties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()) { - getPropertiesBuilder().mergeFrom(value); - } else { - properties_ = value; - } - } else { - propertiesBuilder_.mergeFrom(value); - } - if (properties_ != null) { - bitField0_ |= 0x00000001; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder clearProperties() { - bitField0_ = (bitField0_ & ~0x00000001); - properties_ = null; - if (propertiesBuilder_ != null) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder getPropertiesBuilder() { - bitField0_ |= 0x00000001; - onChanged(); - return getPropertiesFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder() { - if (propertiesBuilder_ != null) { - return propertiesBuilder_.getMessageOrBuilder(); - } else { - return properties_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; - } - } - /** - * .weaviate.v1.PropertiesResult properties = 1; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder> - getPropertiesFieldBuilder() { - if (propertiesBuilder_ == null) { - propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder>( - getProperties(), - getParentForChildren(), - isClean()); - properties_ = null; - } - return propertiesBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult metadata_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder> metadataBuilder_; - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return Whether the metadata field is set. - */ - public boolean hasMetadata() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - * @return The metadata. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata() { - if (metadataBuilder_ == null) { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } else { - return metadataBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult value) { - if (metadataBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - metadata_ = value; - } else { - metadataBuilder_.setMessage(value); - } - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public Builder setMetadata( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder builderForValue) { - if (metadataBuilder_ == null) { - metadata_ = builderForValue.build(); - } else { - metadataBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult value) { - if (metadataBuilder_ == null) { - if (((bitField0_ & 0x00000002) != 0) && - metadata_ != null && - metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) { - getMetadataBuilder().mergeFrom(value); - } else { - metadata_ = value; - } - } else { - metadataBuilder_.mergeFrom(value); - } - if (metadata_ != null) { - bitField0_ |= 0x00000002; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public Builder clearMetadata() { - bitField0_ = (bitField0_ & ~0x00000002); - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder getMetadataBuilder() { - bitField0_ |= 0x00000002; - onChanged(); - return getMetadataFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { - if (metadataBuilder_ != null) { - return metadataBuilder_.getMessageOrBuilder(); - } else { - return metadata_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - } - /** - * .weaviate.v1.MetadataResult metadata = 2; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder> - getMetadataFieldBuilder() { - if (metadataBuilder_ == null) { - metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder>( - getMetadata(), - getParentForChildren(), - isClean()); - metadata_ = null; - } - return metadataBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult generative_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeBuilder_; - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return Whether the generative field is set. - */ - public boolean hasGenerative() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - * @return The generative. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getGenerative() { - if (generativeBuilder_ == null) { - return generative_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; - } else { - return generativeBuilder_.getMessage(); - } - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public Builder setGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - generative_ = value; - } else { - generativeBuilder_.setMessage(value); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public Builder setGenerative( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { - if (generativeBuilder_ == null) { - generative_ = builderForValue.build(); - } else { - generativeBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public Builder mergeGenerative(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult value) { - if (generativeBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0) && - generative_ != null && - generative_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { - getGenerativeBuilder().mergeFrom(value); - } else { - generative_ = value; - } - } else { - generativeBuilder_.mergeFrom(value); - } - if (generative_ != null) { - bitField0_ |= 0x00000004; - onChanged(); - } - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public Builder clearGenerative() { - bitField0_ = (bitField0_ & ~0x00000004); - generative_ = null; - if (generativeBuilder_ != null) { - generativeBuilder_.dispose(); - generativeBuilder_ = null; - } - onChanged(); - return this; - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeBuilder() { - bitField0_ |= 0x00000004; - onChanged(); - return getGenerativeFieldBuilder().getBuilder(); - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder() { - if (generativeBuilder_ != null) { - return generativeBuilder_.getMessageOrBuilder(); - } else { - return generative_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; - } - } - /** - * optional .weaviate.v1.GenerativeResult generative = 3; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder> - getGenerativeFieldBuilder() { - if (generativeBuilder_ == null) { - generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder>( - getGenerative(), - getParentForChildren(), - isClean()); - generative_ = null; - } - return generativeBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchResult) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.SearchResult) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public SearchResult parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchResult getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface MetadataResultOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.MetadataResult) - com.google.protobuf.MessageOrBuilder { - - /** - * string id = 1; - * @return The id. - */ - java.lang.String getId(); - /** - * string id = 1; - * @return The bytes for id. - */ - com.google.protobuf.ByteString - getIdBytes(); - - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return A list containing the vector. - */ - @java.lang.Deprecated java.util.List getVectorList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return The count of vector. - */ - @java.lang.Deprecated int getVectorCount(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated float getVector(int index); - - /** - * int64 creation_time_unix = 3; - * @return The creationTimeUnix. - */ - long getCreationTimeUnix(); - - /** - * bool creation_time_unix_present = 4; - * @return The creationTimeUnixPresent. - */ - boolean getCreationTimeUnixPresent(); - - /** - * int64 last_update_time_unix = 5; - * @return The lastUpdateTimeUnix. - */ - long getLastUpdateTimeUnix(); - - /** - * bool last_update_time_unix_present = 6; - * @return The lastUpdateTimeUnixPresent. - */ - boolean getLastUpdateTimeUnixPresent(); - - /** - * float distance = 7; - * @return The distance. - */ - float getDistance(); - - /** - * bool distance_present = 8; - * @return The distancePresent. - */ - boolean getDistancePresent(); - - /** - * float certainty = 9; - * @return The certainty. - */ - float getCertainty(); - - /** - * bool certainty_present = 10; - * @return The certaintyPresent. - */ - boolean getCertaintyPresent(); - - /** - * float score = 11; - * @return The score. - */ - float getScore(); - - /** - * bool score_present = 12; - * @return The scorePresent. - */ - boolean getScorePresent(); - - /** - * string explain_score = 13; - * @return The explainScore. - */ - java.lang.String getExplainScore(); - /** - * string explain_score = 13; - * @return The bytes for explainScore. - */ - com.google.protobuf.ByteString - getExplainScoreBytes(); - - /** - * bool explain_score_present = 14; - * @return The explainScorePresent. - */ - boolean getExplainScorePresent(); - - /** - * optional bool is_consistent = 15; - * @return Whether the isConsistent field is set. - */ - boolean hasIsConsistent(); - /** - * optional bool is_consistent = 15; - * @return The isConsistent. - */ - boolean getIsConsistent(); - - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The generative. - */ - @java.lang.Deprecated java.lang.String getGenerative(); - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The bytes for generative. - */ - @java.lang.Deprecated com.google.protobuf.ByteString - getGenerativeBytes(); - - /** - * bool generative_present = 17 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. - * See v1/search_get.proto;l=160 - * @return The generativePresent. - */ - @java.lang.Deprecated boolean getGenerativePresent(); - - /** - * bool is_consistent_present = 18; - * @return The isConsistentPresent. - */ - boolean getIsConsistentPresent(); - - /** - * bytes vector_bytes = 19; - * @return The vectorBytes. - */ - com.google.protobuf.ByteString getVectorBytes(); - - /** - * bytes id_as_bytes = 20; - * @return The idAsBytes. - */ - com.google.protobuf.ByteString getIdAsBytes(); - - /** - * double rerank_score = 21; - * @return The rerankScore. - */ - double getRerankScore(); - - /** - * bool rerank_score_present = 22; - * @return The rerankScorePresent. - */ - boolean getRerankScorePresent(); - - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - java.util.List - getVectorsList(); - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index); - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - int getVectorsCount(); - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - java.util.List - getVectorsOrBuilderList(); - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index); - } - /** - * Protobuf type {@code weaviate.v1.MetadataResult} - */ - public static final class MetadataResult extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.MetadataResult) - MetadataResultOrBuilder { - private static final long serialVersionUID = 0L; - // Use MetadataResult.newBuilder() to construct. - private MetadataResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private MetadataResult() { - id_ = ""; - vector_ = emptyFloatList(); - explainScore_ = ""; - generative_ = ""; - vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - idAsBytes_ = com.google.protobuf.ByteString.EMPTY; - vectors_ = java.util.Collections.emptyList(); - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new MetadataResult(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder.class); - } - - private int bitField0_; - public static final int ID_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private volatile java.lang.Object id_ = ""; - /** - * string id = 1; - * @return The id. - */ - @java.lang.Override - public java.lang.String getId() { - java.lang.Object ref = id_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - id_ = s; - return s; - } - } - /** - * string id = 1; - * @return The bytes for id. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getIdBytes() { - java.lang.Object ref = id_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - id_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int VECTOR_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private com.google.protobuf.Internal.FloatList vector_ = - emptyFloatList(); - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return A list containing the vector. - */ - @java.lang.Override - @java.lang.Deprecated public java.util.List - getVectorList() { - return vector_; - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return The count of vector. - */ - @java.lang.Deprecated public int getVectorCount() { - return vector_.size(); - } - /** - *
-     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-     * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated public float getVector(int index) { - return vector_.getFloat(index); - } - private int vectorMemoizedSerializedSize = -1; - - public static final int CREATION_TIME_UNIX_FIELD_NUMBER = 3; - private long creationTimeUnix_ = 0L; - /** - * int64 creation_time_unix = 3; - * @return The creationTimeUnix. - */ - @java.lang.Override - public long getCreationTimeUnix() { - return creationTimeUnix_; - } - - public static final int CREATION_TIME_UNIX_PRESENT_FIELD_NUMBER = 4; - private boolean creationTimeUnixPresent_ = false; - /** - * bool creation_time_unix_present = 4; - * @return The creationTimeUnixPresent. - */ - @java.lang.Override - public boolean getCreationTimeUnixPresent() { - return creationTimeUnixPresent_; - } - - public static final int LAST_UPDATE_TIME_UNIX_FIELD_NUMBER = 5; - private long lastUpdateTimeUnix_ = 0L; - /** - * int64 last_update_time_unix = 5; - * @return The lastUpdateTimeUnix. - */ - @java.lang.Override - public long getLastUpdateTimeUnix() { - return lastUpdateTimeUnix_; - } - - public static final int LAST_UPDATE_TIME_UNIX_PRESENT_FIELD_NUMBER = 6; - private boolean lastUpdateTimeUnixPresent_ = false; - /** - * bool last_update_time_unix_present = 6; - * @return The lastUpdateTimeUnixPresent. - */ - @java.lang.Override - public boolean getLastUpdateTimeUnixPresent() { - return lastUpdateTimeUnixPresent_; - } - - public static final int DISTANCE_FIELD_NUMBER = 7; - private float distance_ = 0F; - /** - * float distance = 7; - * @return The distance. - */ - @java.lang.Override - public float getDistance() { - return distance_; - } - - public static final int DISTANCE_PRESENT_FIELD_NUMBER = 8; - private boolean distancePresent_ = false; - /** - * bool distance_present = 8; - * @return The distancePresent. - */ - @java.lang.Override - public boolean getDistancePresent() { - return distancePresent_; - } - - public static final int CERTAINTY_FIELD_NUMBER = 9; - private float certainty_ = 0F; - /** - * float certainty = 9; - * @return The certainty. - */ - @java.lang.Override - public float getCertainty() { - return certainty_; - } - - public static final int CERTAINTY_PRESENT_FIELD_NUMBER = 10; - private boolean certaintyPresent_ = false; - /** - * bool certainty_present = 10; - * @return The certaintyPresent. - */ - @java.lang.Override - public boolean getCertaintyPresent() { - return certaintyPresent_; - } - - public static final int SCORE_FIELD_NUMBER = 11; - private float score_ = 0F; - /** - * float score = 11; - * @return The score. - */ - @java.lang.Override - public float getScore() { - return score_; - } - - public static final int SCORE_PRESENT_FIELD_NUMBER = 12; - private boolean scorePresent_ = false; - /** - * bool score_present = 12; - * @return The scorePresent. - */ - @java.lang.Override - public boolean getScorePresent() { - return scorePresent_; - } - - public static final int EXPLAIN_SCORE_FIELD_NUMBER = 13; - @SuppressWarnings("serial") - private volatile java.lang.Object explainScore_ = ""; - /** - * string explain_score = 13; - * @return The explainScore. - */ - @java.lang.Override - public java.lang.String getExplainScore() { - java.lang.Object ref = explainScore_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - explainScore_ = s; - return s; - } - } - /** - * string explain_score = 13; - * @return The bytes for explainScore. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getExplainScoreBytes() { - java.lang.Object ref = explainScore_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - explainScore_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int EXPLAIN_SCORE_PRESENT_FIELD_NUMBER = 14; - private boolean explainScorePresent_ = false; - /** - * bool explain_score_present = 14; - * @return The explainScorePresent. - */ - @java.lang.Override - public boolean getExplainScorePresent() { - return explainScorePresent_; - } - - public static final int IS_CONSISTENT_FIELD_NUMBER = 15; - private boolean isConsistent_ = false; - /** - * optional bool is_consistent = 15; - * @return Whether the isConsistent field is set. - */ - @java.lang.Override - public boolean hasIsConsistent() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * optional bool is_consistent = 15; - * @return The isConsistent. - */ - @java.lang.Override - public boolean getIsConsistent() { - return isConsistent_; - } - - public static final int GENERATIVE_FIELD_NUMBER = 16; - @SuppressWarnings("serial") - private volatile java.lang.Object generative_ = ""; - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The generative. - */ - @java.lang.Override - @java.lang.Deprecated public java.lang.String getGenerative() { - java.lang.Object ref = generative_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - generative_ = s; - return s; - } - } - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The bytes for generative. - */ - @java.lang.Override - @java.lang.Deprecated public com.google.protobuf.ByteString - getGenerativeBytes() { - java.lang.Object ref = generative_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - generative_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int GENERATIVE_PRESENT_FIELD_NUMBER = 17; - private boolean generativePresent_ = false; - /** - * bool generative_present = 17 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. - * See v1/search_get.proto;l=160 - * @return The generativePresent. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getGenerativePresent() { - return generativePresent_; - } - - public static final int IS_CONSISTENT_PRESENT_FIELD_NUMBER = 18; - private boolean isConsistentPresent_ = false; - /** - * bool is_consistent_present = 18; - * @return The isConsistentPresent. - */ - @java.lang.Override - public boolean getIsConsistentPresent() { - return isConsistentPresent_; - } - - public static final int VECTOR_BYTES_FIELD_NUMBER = 19; - private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes vector_bytes = 19; - * @return The vectorBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getVectorBytes() { - return vectorBytes_; - } - - public static final int ID_AS_BYTES_FIELD_NUMBER = 20; - private com.google.protobuf.ByteString idAsBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes id_as_bytes = 20; - * @return The idAsBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getIdAsBytes() { - return idAsBytes_; - } - - public static final int RERANK_SCORE_FIELD_NUMBER = 21; - private double rerankScore_ = 0D; - /** - * double rerank_score = 21; - * @return The rerankScore. - */ - @java.lang.Override - public double getRerankScore() { - return rerankScore_; - } - - public static final int RERANK_SCORE_PRESENT_FIELD_NUMBER = 22; - private boolean rerankScorePresent_ = false; - /** - * bool rerank_score_present = 22; - * @return The rerankScorePresent. - */ - @java.lang.Override - public boolean getRerankScorePresent() { - return rerankScorePresent_; - } - - public static final int VECTORS_FIELD_NUMBER = 23; - @SuppressWarnings("serial") - private java.util.List vectors_; - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public java.util.List getVectorsList() { - return vectors_; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public java.util.List - getVectorsOrBuilderList() { - return vectors_; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public int getVectorsCount() { - return vectors_.size(); - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) { - return vectors_.get(index); - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index) { - return vectors_.get(index); - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - getSerializedSize(); - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(id_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 1, id_); - } - if (getVectorList().size() > 0) { - output.writeUInt32NoTag(18); - output.writeUInt32NoTag(vectorMemoizedSerializedSize); - } - for (int i = 0; i < vector_.size(); i++) { - output.writeFloatNoTag(vector_.getFloat(i)); - } - if (creationTimeUnix_ != 0L) { - output.writeInt64(3, creationTimeUnix_); - } - if (creationTimeUnixPresent_ != false) { - output.writeBool(4, creationTimeUnixPresent_); - } - if (lastUpdateTimeUnix_ != 0L) { - output.writeInt64(5, lastUpdateTimeUnix_); - } - if (lastUpdateTimeUnixPresent_ != false) { - output.writeBool(6, lastUpdateTimeUnixPresent_); - } - if (java.lang.Float.floatToRawIntBits(distance_) != 0) { - output.writeFloat(7, distance_); - } - if (distancePresent_ != false) { - output.writeBool(8, distancePresent_); - } - if (java.lang.Float.floatToRawIntBits(certainty_) != 0) { - output.writeFloat(9, certainty_); - } - if (certaintyPresent_ != false) { - output.writeBool(10, certaintyPresent_); - } - if (java.lang.Float.floatToRawIntBits(score_) != 0) { - output.writeFloat(11, score_); - } - if (scorePresent_ != false) { - output.writeBool(12, scorePresent_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(explainScore_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 13, explainScore_); - } - if (explainScorePresent_ != false) { - output.writeBool(14, explainScorePresent_); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeBool(15, isConsistent_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(generative_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 16, generative_); - } - if (generativePresent_ != false) { - output.writeBool(17, generativePresent_); - } - if (isConsistentPresent_ != false) { - output.writeBool(18, isConsistentPresent_); - } - if (!vectorBytes_.isEmpty()) { - output.writeBytes(19, vectorBytes_); - } - if (!idAsBytes_.isEmpty()) { - output.writeBytes(20, idAsBytes_); - } - if (java.lang.Double.doubleToRawLongBits(rerankScore_) != 0) { - output.writeDouble(21, rerankScore_); - } - if (rerankScorePresent_ != false) { - output.writeBool(22, rerankScorePresent_); - } - for (int i = 0; i < vectors_.size(); i++) { - output.writeMessage(23, vectors_.get(i)); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(id_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, id_); - } - { - int dataSize = 0; - dataSize = 4 * getVectorList().size(); - size += dataSize; - if (!getVectorList().isEmpty()) { - size += 1; - size += com.google.protobuf.CodedOutputStream - .computeInt32SizeNoTag(dataSize); - } - vectorMemoizedSerializedSize = dataSize; - } - if (creationTimeUnix_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(3, creationTimeUnix_); - } - if (creationTimeUnixPresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(4, creationTimeUnixPresent_); - } - if (lastUpdateTimeUnix_ != 0L) { - size += com.google.protobuf.CodedOutputStream - .computeInt64Size(5, lastUpdateTimeUnix_); - } - if (lastUpdateTimeUnixPresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(6, lastUpdateTimeUnixPresent_); - } - if (java.lang.Float.floatToRawIntBits(distance_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(7, distance_); - } - if (distancePresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(8, distancePresent_); - } - if (java.lang.Float.floatToRawIntBits(certainty_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(9, certainty_); - } - if (certaintyPresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(10, certaintyPresent_); - } - if (java.lang.Float.floatToRawIntBits(score_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeFloatSize(11, score_); - } - if (scorePresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(12, scorePresent_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(explainScore_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(13, explainScore_); - } - if (explainScorePresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(14, explainScorePresent_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(15, isConsistent_); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(generative_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(16, generative_); - } - if (generativePresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(17, generativePresent_); - } - if (isConsistentPresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(18, isConsistentPresent_); - } - if (!vectorBytes_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(19, vectorBytes_); - } - if (!idAsBytes_.isEmpty()) { - size += com.google.protobuf.CodedOutputStream - .computeBytesSize(20, idAsBytes_); - } - if (java.lang.Double.doubleToRawLongBits(rerankScore_) != 0) { - size += com.google.protobuf.CodedOutputStream - .computeDoubleSize(21, rerankScore_); - } - if (rerankScorePresent_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(22, rerankScorePresent_); - } - for (int i = 0; i < vectors_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(23, vectors_.get(i)); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult) obj; - - if (!getId() - .equals(other.getId())) return false; - if (!getVectorList() - .equals(other.getVectorList())) return false; - if (getCreationTimeUnix() - != other.getCreationTimeUnix()) return false; - if (getCreationTimeUnixPresent() - != other.getCreationTimeUnixPresent()) return false; - if (getLastUpdateTimeUnix() - != other.getLastUpdateTimeUnix()) return false; - if (getLastUpdateTimeUnixPresent() - != other.getLastUpdateTimeUnixPresent()) return false; - if (java.lang.Float.floatToIntBits(getDistance()) - != java.lang.Float.floatToIntBits( - other.getDistance())) return false; - if (getDistancePresent() - != other.getDistancePresent()) return false; - if (java.lang.Float.floatToIntBits(getCertainty()) - != java.lang.Float.floatToIntBits( - other.getCertainty())) return false; - if (getCertaintyPresent() - != other.getCertaintyPresent()) return false; - if (java.lang.Float.floatToIntBits(getScore()) - != java.lang.Float.floatToIntBits( - other.getScore())) return false; - if (getScorePresent() - != other.getScorePresent()) return false; - if (!getExplainScore() - .equals(other.getExplainScore())) return false; - if (getExplainScorePresent() - != other.getExplainScorePresent()) return false; - if (hasIsConsistent() != other.hasIsConsistent()) return false; - if (hasIsConsistent()) { - if (getIsConsistent() - != other.getIsConsistent()) return false; - } - if (!getGenerative() - .equals(other.getGenerative())) return false; - if (getGenerativePresent() - != other.getGenerativePresent()) return false; - if (getIsConsistentPresent() - != other.getIsConsistentPresent()) return false; - if (!getVectorBytes() - .equals(other.getVectorBytes())) return false; - if (!getIdAsBytes() - .equals(other.getIdAsBytes())) return false; - if (java.lang.Double.doubleToLongBits(getRerankScore()) - != java.lang.Double.doubleToLongBits( - other.getRerankScore())) return false; - if (getRerankScorePresent() - != other.getRerankScorePresent()) return false; - if (!getVectorsList() - .equals(other.getVectorsList())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - hash = (37 * hash) + ID_FIELD_NUMBER; - hash = (53 * hash) + getId().hashCode(); - if (getVectorCount() > 0) { - hash = (37 * hash) + VECTOR_FIELD_NUMBER; - hash = (53 * hash) + getVectorList().hashCode(); - } - hash = (37 * hash) + CREATION_TIME_UNIX_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getCreationTimeUnix()); - hash = (37 * hash) + CREATION_TIME_UNIX_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getCreationTimeUnixPresent()); - hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - getLastUpdateTimeUnix()); - hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getLastUpdateTimeUnixPresent()); - hash = (37 * hash) + DISTANCE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getDistance()); - hash = (37 * hash) + DISTANCE_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getDistancePresent()); - hash = (37 * hash) + CERTAINTY_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getCertainty()); - hash = (37 * hash) + CERTAINTY_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getCertaintyPresent()); - hash = (37 * hash) + SCORE_FIELD_NUMBER; - hash = (53 * hash) + java.lang.Float.floatToIntBits( - getScore()); - hash = (37 * hash) + SCORE_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getScorePresent()); - hash = (37 * hash) + EXPLAIN_SCORE_FIELD_NUMBER; - hash = (53 * hash) + getExplainScore().hashCode(); - hash = (37 * hash) + EXPLAIN_SCORE_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getExplainScorePresent()); - if (hasIsConsistent()) { - hash = (37 * hash) + IS_CONSISTENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsConsistent()); - } - hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; - hash = (53 * hash) + getGenerative().hashCode(); - hash = (37 * hash) + GENERATIVE_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getGenerativePresent()); - hash = (37 * hash) + IS_CONSISTENT_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getIsConsistentPresent()); - hash = (37 * hash) + VECTOR_BYTES_FIELD_NUMBER; - hash = (53 * hash) + getVectorBytes().hashCode(); - hash = (37 * hash) + ID_AS_BYTES_FIELD_NUMBER; - hash = (53 * hash) + getIdAsBytes().hashCode(); - hash = (37 * hash) + RERANK_SCORE_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashLong( - java.lang.Double.doubleToLongBits(getRerankScore())); - hash = (37 * hash) + RERANK_SCORE_PRESENT_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getRerankScorePresent()); - if (getVectorsCount() > 0) { - hash = (37 * hash) + VECTORS_FIELD_NUMBER; - hash = (53 * hash) + getVectorsList().hashCode(); - } - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.MetadataResult} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.MetadataResult) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - id_ = ""; - vector_ = emptyFloatList(); - creationTimeUnix_ = 0L; - creationTimeUnixPresent_ = false; - lastUpdateTimeUnix_ = 0L; - lastUpdateTimeUnixPresent_ = false; - distance_ = 0F; - distancePresent_ = false; - certainty_ = 0F; - certaintyPresent_ = false; - score_ = 0F; - scorePresent_ = false; - explainScore_ = ""; - explainScorePresent_ = false; - isConsistent_ = false; - generative_ = ""; - generativePresent_ = false; - isConsistentPresent_ = false; - vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - idAsBytes_ = com.google.protobuf.ByteString.EMPTY; - rerankScore_ = 0D; - rerankScorePresent_ = false; - if (vectorsBuilder_ == null) { - vectors_ = java.util.Collections.emptyList(); - } else { - vectors_ = null; - vectorsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00400000); - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult result) { - if (vectorsBuilder_ == null) { - if (((bitField0_ & 0x00400000) != 0)) { - vectors_ = java.util.Collections.unmodifiableList(vectors_); - bitField0_ = (bitField0_ & ~0x00400000); - } - result.vectors_ = vectors_; - } else { - result.vectors_ = vectorsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000001) != 0)) { - result.id_ = id_; - } - if (((from_bitField0_ & 0x00000002) != 0)) { - vector_.makeImmutable(); - result.vector_ = vector_; - } - if (((from_bitField0_ & 0x00000004) != 0)) { - result.creationTimeUnix_ = creationTimeUnix_; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.creationTimeUnixPresent_ = creationTimeUnixPresent_; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.lastUpdateTimeUnix_ = lastUpdateTimeUnix_; - } - if (((from_bitField0_ & 0x00000020) != 0)) { - result.lastUpdateTimeUnixPresent_ = lastUpdateTimeUnixPresent_; - } - if (((from_bitField0_ & 0x00000040) != 0)) { - result.distance_ = distance_; - } - if (((from_bitField0_ & 0x00000080) != 0)) { - result.distancePresent_ = distancePresent_; - } - if (((from_bitField0_ & 0x00000100) != 0)) { - result.certainty_ = certainty_; - } - if (((from_bitField0_ & 0x00000200) != 0)) { - result.certaintyPresent_ = certaintyPresent_; - } - if (((from_bitField0_ & 0x00000400) != 0)) { - result.score_ = score_; - } - if (((from_bitField0_ & 0x00000800) != 0)) { - result.scorePresent_ = scorePresent_; - } - if (((from_bitField0_ & 0x00001000) != 0)) { - result.explainScore_ = explainScore_; - } - if (((from_bitField0_ & 0x00002000) != 0)) { - result.explainScorePresent_ = explainScorePresent_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00004000) != 0)) { - result.isConsistent_ = isConsistent_; - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00008000) != 0)) { - result.generative_ = generative_; - } - if (((from_bitField0_ & 0x00010000) != 0)) { - result.generativePresent_ = generativePresent_; - } - if (((from_bitField0_ & 0x00020000) != 0)) { - result.isConsistentPresent_ = isConsistentPresent_; - } - if (((from_bitField0_ & 0x00040000) != 0)) { - result.vectorBytes_ = vectorBytes_; - } - if (((from_bitField0_ & 0x00080000) != 0)) { - result.idAsBytes_ = idAsBytes_; - } - if (((from_bitField0_ & 0x00100000) != 0)) { - result.rerankScore_ = rerankScore_; - } - if (((from_bitField0_ & 0x00200000) != 0)) { - result.rerankScorePresent_ = rerankScorePresent_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) return this; - if (!other.getId().isEmpty()) { - id_ = other.id_; - bitField0_ |= 0x00000001; - onChanged(); - } - if (!other.vector_.isEmpty()) { - if (vector_.isEmpty()) { - vector_ = other.vector_; - vector_.makeImmutable(); - bitField0_ |= 0x00000002; - } else { - ensureVectorIsMutable(); - vector_.addAll(other.vector_); - } - onChanged(); - } - if (other.getCreationTimeUnix() != 0L) { - setCreationTimeUnix(other.getCreationTimeUnix()); - } - if (other.getCreationTimeUnixPresent() != false) { - setCreationTimeUnixPresent(other.getCreationTimeUnixPresent()); - } - if (other.getLastUpdateTimeUnix() != 0L) { - setLastUpdateTimeUnix(other.getLastUpdateTimeUnix()); - } - if (other.getLastUpdateTimeUnixPresent() != false) { - setLastUpdateTimeUnixPresent(other.getLastUpdateTimeUnixPresent()); - } - if (other.getDistance() != 0F) { - setDistance(other.getDistance()); - } - if (other.getDistancePresent() != false) { - setDistancePresent(other.getDistancePresent()); - } - if (other.getCertainty() != 0F) { - setCertainty(other.getCertainty()); - } - if (other.getCertaintyPresent() != false) { - setCertaintyPresent(other.getCertaintyPresent()); - } - if (other.getScore() != 0F) { - setScore(other.getScore()); - } - if (other.getScorePresent() != false) { - setScorePresent(other.getScorePresent()); - } - if (!other.getExplainScore().isEmpty()) { - explainScore_ = other.explainScore_; - bitField0_ |= 0x00001000; - onChanged(); - } - if (other.getExplainScorePresent() != false) { - setExplainScorePresent(other.getExplainScorePresent()); - } - if (other.hasIsConsistent()) { - setIsConsistent(other.getIsConsistent()); - } - if (!other.getGenerative().isEmpty()) { - generative_ = other.generative_; - bitField0_ |= 0x00008000; - onChanged(); - } - if (other.getGenerativePresent() != false) { - setGenerativePresent(other.getGenerativePresent()); - } - if (other.getIsConsistentPresent() != false) { - setIsConsistentPresent(other.getIsConsistentPresent()); - } - if (other.getVectorBytes() != com.google.protobuf.ByteString.EMPTY) { - setVectorBytes(other.getVectorBytes()); - } - if (other.getIdAsBytes() != com.google.protobuf.ByteString.EMPTY) { - setIdAsBytes(other.getIdAsBytes()); - } - if (other.getRerankScore() != 0D) { - setRerankScore(other.getRerankScore()); - } - if (other.getRerankScorePresent() != false) { - setRerankScorePresent(other.getRerankScorePresent()); - } - if (vectorsBuilder_ == null) { - if (!other.vectors_.isEmpty()) { - if (vectors_.isEmpty()) { - vectors_ = other.vectors_; - bitField0_ = (bitField0_ & ~0x00400000); - } else { - ensureVectorsIsMutable(); - vectors_.addAll(other.vectors_); - } - onChanged(); - } - } else { - if (!other.vectors_.isEmpty()) { - if (vectorsBuilder_.isEmpty()) { - vectorsBuilder_.dispose(); - vectorsBuilder_ = null; - vectors_ = other.vectors_; - bitField0_ = (bitField0_ & ~0x00400000); - vectorsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getVectorsFieldBuilder() : null; - } else { - vectorsBuilder_.addAllMessages(other.vectors_); - } - } - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - id_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000001; - break; - } // case 10 - case 21: { - float v = input.readFloat(); - ensureVectorIsMutable(); - vector_.addFloat(v); - break; - } // case 21 - case 18: { - int length = input.readRawVarint32(); - int limit = input.pushLimit(length); - int alloc = length > 4096 ? 4096 : length; - ensureVectorIsMutable(alloc / 4); - while (input.getBytesUntilLimit() > 0) { - vector_.addFloat(input.readFloat()); - } - input.popLimit(limit); - break; - } // case 18 - case 24: { - creationTimeUnix_ = input.readInt64(); - bitField0_ |= 0x00000004; - break; - } // case 24 - case 32: { - creationTimeUnixPresent_ = input.readBool(); - bitField0_ |= 0x00000008; - break; - } // case 32 - case 40: { - lastUpdateTimeUnix_ = input.readInt64(); - bitField0_ |= 0x00000010; - break; - } // case 40 - case 48: { - lastUpdateTimeUnixPresent_ = input.readBool(); - bitField0_ |= 0x00000020; - break; - } // case 48 - case 61: { - distance_ = input.readFloat(); - bitField0_ |= 0x00000040; - break; - } // case 61 - case 64: { - distancePresent_ = input.readBool(); - bitField0_ |= 0x00000080; - break; - } // case 64 - case 77: { - certainty_ = input.readFloat(); - bitField0_ |= 0x00000100; - break; - } // case 77 - case 80: { - certaintyPresent_ = input.readBool(); - bitField0_ |= 0x00000200; - break; - } // case 80 - case 93: { - score_ = input.readFloat(); - bitField0_ |= 0x00000400; - break; - } // case 93 - case 96: { - scorePresent_ = input.readBool(); - bitField0_ |= 0x00000800; - break; - } // case 96 - case 106: { - explainScore_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00001000; - break; - } // case 106 - case 112: { - explainScorePresent_ = input.readBool(); - bitField0_ |= 0x00002000; - break; - } // case 112 - case 120: { - isConsistent_ = input.readBool(); - bitField0_ |= 0x00004000; - break; - } // case 120 - case 130: { - generative_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00008000; - break; - } // case 130 - case 136: { - generativePresent_ = input.readBool(); - bitField0_ |= 0x00010000; - break; - } // case 136 - case 144: { - isConsistentPresent_ = input.readBool(); - bitField0_ |= 0x00020000; - break; - } // case 144 - case 154: { - vectorBytes_ = input.readBytes(); - bitField0_ |= 0x00040000; - break; - } // case 154 - case 162: { - idAsBytes_ = input.readBytes(); - bitField0_ |= 0x00080000; - break; - } // case 162 - case 169: { - rerankScore_ = input.readDouble(); - bitField0_ |= 0x00100000; - break; - } // case 169 - case 176: { - rerankScorePresent_ = input.readBool(); - bitField0_ |= 0x00200000; - break; - } // case 176 - case 186: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.parser(), - extensionRegistry); - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(m); - } else { - vectorsBuilder_.addMessage(m); - } - break; - } // case 186 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.lang.Object id_ = ""; - /** - * string id = 1; - * @return The id. - */ - public java.lang.String getId() { - java.lang.Object ref = id_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - id_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string id = 1; - * @return The bytes for id. - */ - public com.google.protobuf.ByteString - getIdBytes() { - java.lang.Object ref = id_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - id_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string id = 1; - * @param value The id to set. - * @return This builder for chaining. - */ - public Builder setId( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - id_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - /** - * string id = 1; - * @return This builder for chaining. - */ - public Builder clearId() { - id_ = getDefaultInstance().getId(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - return this; - } - /** - * string id = 1; - * @param value The bytes for id to set. - * @return This builder for chaining. - */ - public Builder setIdBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - id_ = value; - bitField0_ |= 0x00000001; - onChanged(); - return this; - } - - private com.google.protobuf.Internal.FloatList vector_ = emptyFloatList(); - private void ensureVectorIsMutable() { - if (!vector_.isModifiable()) { - vector_ = makeMutableCopy(vector_); - } - bitField0_ |= 0x00000002; - } - private void ensureVectorIsMutable(int capacity) { - if (!vector_.isModifiable()) { - vector_ = makeMutableCopy(vector_, capacity); - } - bitField0_ |= 0x00000002; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return A list containing the vector. - */ - @java.lang.Deprecated public java.util.List - getVectorList() { - vector_.makeImmutable(); - return vector_; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return The count of vector. - */ - @java.lang.Deprecated public int getVectorCount() { - return vector_.size(); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param index The index of the element to return. - * @return The vector at the given index. - */ - @java.lang.Deprecated public float getVector(int index) { - return vector_.getFloat(index); - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param index The index to set the value at. - * @param value The vector to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setVector( - int index, float value) { - - ensureVectorIsMutable(); - vector_.setFloat(index, value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param value The vector to add. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder addVector(float value) { - - ensureVectorIsMutable(); - vector_.addFloat(value); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @param values The vector to add. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder addAllVector( - java.lang.Iterable values) { - ensureVectorIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, vector_); - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - *
-       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
-       * 
- * - * repeated float vector = 2 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.vector is deprecated. - * See v1/search_get.proto;l=145 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearVector() { - vector_ = emptyFloatList(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - - private long creationTimeUnix_ ; - /** - * int64 creation_time_unix = 3; - * @return The creationTimeUnix. - */ - @java.lang.Override - public long getCreationTimeUnix() { - return creationTimeUnix_; - } - /** - * int64 creation_time_unix = 3; - * @param value The creationTimeUnix to set. - * @return This builder for chaining. - */ - public Builder setCreationTimeUnix(long value) { - - creationTimeUnix_ = value; - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * int64 creation_time_unix = 3; - * @return This builder for chaining. - */ - public Builder clearCreationTimeUnix() { - bitField0_ = (bitField0_ & ~0x00000004); - creationTimeUnix_ = 0L; - onChanged(); - return this; - } - - private boolean creationTimeUnixPresent_ ; - /** - * bool creation_time_unix_present = 4; - * @return The creationTimeUnixPresent. - */ - @java.lang.Override - public boolean getCreationTimeUnixPresent() { - return creationTimeUnixPresent_; - } - /** - * bool creation_time_unix_present = 4; - * @param value The creationTimeUnixPresent to set. - * @return This builder for chaining. - */ - public Builder setCreationTimeUnixPresent(boolean value) { - - creationTimeUnixPresent_ = value; - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * bool creation_time_unix_present = 4; - * @return This builder for chaining. - */ - public Builder clearCreationTimeUnixPresent() { - bitField0_ = (bitField0_ & ~0x00000008); - creationTimeUnixPresent_ = false; - onChanged(); - return this; - } - - private long lastUpdateTimeUnix_ ; - /** - * int64 last_update_time_unix = 5; - * @return The lastUpdateTimeUnix. - */ - @java.lang.Override - public long getLastUpdateTimeUnix() { - return lastUpdateTimeUnix_; - } - /** - * int64 last_update_time_unix = 5; - * @param value The lastUpdateTimeUnix to set. - * @return This builder for chaining. - */ - public Builder setLastUpdateTimeUnix(long value) { - - lastUpdateTimeUnix_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * int64 last_update_time_unix = 5; - * @return This builder for chaining. - */ - public Builder clearLastUpdateTimeUnix() { - bitField0_ = (bitField0_ & ~0x00000010); - lastUpdateTimeUnix_ = 0L; - onChanged(); - return this; - } - - private boolean lastUpdateTimeUnixPresent_ ; - /** - * bool last_update_time_unix_present = 6; - * @return The lastUpdateTimeUnixPresent. - */ - @java.lang.Override - public boolean getLastUpdateTimeUnixPresent() { - return lastUpdateTimeUnixPresent_; - } - /** - * bool last_update_time_unix_present = 6; - * @param value The lastUpdateTimeUnixPresent to set. - * @return This builder for chaining. - */ - public Builder setLastUpdateTimeUnixPresent(boolean value) { - - lastUpdateTimeUnixPresent_ = value; - bitField0_ |= 0x00000020; - onChanged(); - return this; - } - /** - * bool last_update_time_unix_present = 6; - * @return This builder for chaining. - */ - public Builder clearLastUpdateTimeUnixPresent() { - bitField0_ = (bitField0_ & ~0x00000020); - lastUpdateTimeUnixPresent_ = false; - onChanged(); - return this; - } - - private float distance_ ; - /** - * float distance = 7; - * @return The distance. - */ - @java.lang.Override - public float getDistance() { - return distance_; - } - /** - * float distance = 7; - * @param value The distance to set. - * @return This builder for chaining. - */ - public Builder setDistance(float value) { - - distance_ = value; - bitField0_ |= 0x00000040; - onChanged(); - return this; - } - /** - * float distance = 7; - * @return This builder for chaining. - */ - public Builder clearDistance() { - bitField0_ = (bitField0_ & ~0x00000040); - distance_ = 0F; - onChanged(); - return this; - } - - private boolean distancePresent_ ; - /** - * bool distance_present = 8; - * @return The distancePresent. - */ - @java.lang.Override - public boolean getDistancePresent() { - return distancePresent_; - } - /** - * bool distance_present = 8; - * @param value The distancePresent to set. - * @return This builder for chaining. - */ - public Builder setDistancePresent(boolean value) { - - distancePresent_ = value; - bitField0_ |= 0x00000080; - onChanged(); - return this; - } - /** - * bool distance_present = 8; - * @return This builder for chaining. - */ - public Builder clearDistancePresent() { - bitField0_ = (bitField0_ & ~0x00000080); - distancePresent_ = false; - onChanged(); - return this; - } - - private float certainty_ ; - /** - * float certainty = 9; - * @return The certainty. - */ - @java.lang.Override - public float getCertainty() { - return certainty_; - } - /** - * float certainty = 9; - * @param value The certainty to set. - * @return This builder for chaining. - */ - public Builder setCertainty(float value) { - - certainty_ = value; - bitField0_ |= 0x00000100; - onChanged(); - return this; - } - /** - * float certainty = 9; - * @return This builder for chaining. - */ - public Builder clearCertainty() { - bitField0_ = (bitField0_ & ~0x00000100); - certainty_ = 0F; - onChanged(); - return this; - } - - private boolean certaintyPresent_ ; - /** - * bool certainty_present = 10; - * @return The certaintyPresent. - */ - @java.lang.Override - public boolean getCertaintyPresent() { - return certaintyPresent_; - } - /** - * bool certainty_present = 10; - * @param value The certaintyPresent to set. - * @return This builder for chaining. - */ - public Builder setCertaintyPresent(boolean value) { - - certaintyPresent_ = value; - bitField0_ |= 0x00000200; - onChanged(); - return this; - } - /** - * bool certainty_present = 10; - * @return This builder for chaining. - */ - public Builder clearCertaintyPresent() { - bitField0_ = (bitField0_ & ~0x00000200); - certaintyPresent_ = false; - onChanged(); - return this; - } - - private float score_ ; - /** - * float score = 11; - * @return The score. - */ - @java.lang.Override - public float getScore() { - return score_; - } - /** - * float score = 11; - * @param value The score to set. - * @return This builder for chaining. - */ - public Builder setScore(float value) { - - score_ = value; - bitField0_ |= 0x00000400; - onChanged(); - return this; - } - /** - * float score = 11; - * @return This builder for chaining. - */ - public Builder clearScore() { - bitField0_ = (bitField0_ & ~0x00000400); - score_ = 0F; - onChanged(); - return this; - } - - private boolean scorePresent_ ; - /** - * bool score_present = 12; - * @return The scorePresent. - */ - @java.lang.Override - public boolean getScorePresent() { - return scorePresent_; - } - /** - * bool score_present = 12; - * @param value The scorePresent to set. - * @return This builder for chaining. - */ - public Builder setScorePresent(boolean value) { - - scorePresent_ = value; - bitField0_ |= 0x00000800; - onChanged(); - return this; - } - /** - * bool score_present = 12; - * @return This builder for chaining. - */ - public Builder clearScorePresent() { - bitField0_ = (bitField0_ & ~0x00000800); - scorePresent_ = false; - onChanged(); - return this; - } - - private java.lang.Object explainScore_ = ""; - /** - * string explain_score = 13; - * @return The explainScore. - */ - public java.lang.String getExplainScore() { - java.lang.Object ref = explainScore_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - explainScore_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string explain_score = 13; - * @return The bytes for explainScore. - */ - public com.google.protobuf.ByteString - getExplainScoreBytes() { - java.lang.Object ref = explainScore_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - explainScore_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string explain_score = 13; - * @param value The explainScore to set. - * @return This builder for chaining. - */ - public Builder setExplainScore( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - explainScore_ = value; - bitField0_ |= 0x00001000; - onChanged(); - return this; - } - /** - * string explain_score = 13; - * @return This builder for chaining. - */ - public Builder clearExplainScore() { - explainScore_ = getDefaultInstance().getExplainScore(); - bitField0_ = (bitField0_ & ~0x00001000); - onChanged(); - return this; - } - /** - * string explain_score = 13; - * @param value The bytes for explainScore to set. - * @return This builder for chaining. - */ - public Builder setExplainScoreBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - explainScore_ = value; - bitField0_ |= 0x00001000; - onChanged(); - return this; - } - - private boolean explainScorePresent_ ; - /** - * bool explain_score_present = 14; - * @return The explainScorePresent. - */ - @java.lang.Override - public boolean getExplainScorePresent() { - return explainScorePresent_; - } - /** - * bool explain_score_present = 14; - * @param value The explainScorePresent to set. - * @return This builder for chaining. - */ - public Builder setExplainScorePresent(boolean value) { - - explainScorePresent_ = value; - bitField0_ |= 0x00002000; - onChanged(); - return this; - } - /** - * bool explain_score_present = 14; - * @return This builder for chaining. - */ - public Builder clearExplainScorePresent() { - bitField0_ = (bitField0_ & ~0x00002000); - explainScorePresent_ = false; - onChanged(); - return this; - } - - private boolean isConsistent_ ; - /** - * optional bool is_consistent = 15; - * @return Whether the isConsistent field is set. - */ - @java.lang.Override - public boolean hasIsConsistent() { - return ((bitField0_ & 0x00004000) != 0); - } - /** - * optional bool is_consistent = 15; - * @return The isConsistent. - */ - @java.lang.Override - public boolean getIsConsistent() { - return isConsistent_; - } - /** - * optional bool is_consistent = 15; - * @param value The isConsistent to set. - * @return This builder for chaining. - */ - public Builder setIsConsistent(boolean value) { - - isConsistent_ = value; - bitField0_ |= 0x00004000; - onChanged(); - return this; - } - /** - * optional bool is_consistent = 15; - * @return This builder for chaining. - */ - public Builder clearIsConsistent() { - bitField0_ = (bitField0_ & ~0x00004000); - isConsistent_ = false; - onChanged(); - return this; - } - - private java.lang.Object generative_ = ""; - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The generative. - */ - @java.lang.Deprecated public java.lang.String getGenerative() { - java.lang.Object ref = generative_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - generative_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return The bytes for generative. - */ - @java.lang.Deprecated public com.google.protobuf.ByteString - getGenerativeBytes() { - java.lang.Object ref = generative_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - generative_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @param value The generative to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setGenerative( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - generative_ = value; - bitField0_ |= 0x00008000; - onChanged(); - return this; - } - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearGenerative() { - generative_ = getDefaultInstance().getGenerative(); - bitField0_ = (bitField0_ & ~0x00008000); - onChanged(); - return this; - } - /** - * string generative = 16 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative is deprecated. - * See v1/search_get.proto;l=159 - * @param value The bytes for generative to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setGenerativeBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - generative_ = value; - bitField0_ |= 0x00008000; - onChanged(); - return this; - } - - private boolean generativePresent_ ; - /** - * bool generative_present = 17 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. - * See v1/search_get.proto;l=160 - * @return The generativePresent. - */ - @java.lang.Override - @java.lang.Deprecated public boolean getGenerativePresent() { - return generativePresent_; - } - /** - * bool generative_present = 17 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. - * See v1/search_get.proto;l=160 - * @param value The generativePresent to set. - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder setGenerativePresent(boolean value) { - - generativePresent_ = value; - bitField0_ |= 0x00010000; - onChanged(); - return this; - } - /** - * bool generative_present = 17 [deprecated = true]; - * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. - * See v1/search_get.proto;l=160 - * @return This builder for chaining. - */ - @java.lang.Deprecated public Builder clearGenerativePresent() { - bitField0_ = (bitField0_ & ~0x00010000); - generativePresent_ = false; - onChanged(); - return this; - } - - private boolean isConsistentPresent_ ; - /** - * bool is_consistent_present = 18; - * @return The isConsistentPresent. - */ - @java.lang.Override - public boolean getIsConsistentPresent() { - return isConsistentPresent_; - } - /** - * bool is_consistent_present = 18; - * @param value The isConsistentPresent to set. - * @return This builder for chaining. - */ - public Builder setIsConsistentPresent(boolean value) { - - isConsistentPresent_ = value; - bitField0_ |= 0x00020000; - onChanged(); - return this; - } - /** - * bool is_consistent_present = 18; - * @return This builder for chaining. - */ - public Builder clearIsConsistentPresent() { - bitField0_ = (bitField0_ & ~0x00020000); - isConsistentPresent_ = false; - onChanged(); - return this; - } - - private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes vector_bytes = 19; - * @return The vectorBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getVectorBytes() { - return vectorBytes_; - } - /** - * bytes vector_bytes = 19; - * @param value The vectorBytes to set. - * @return This builder for chaining. - */ - public Builder setVectorBytes(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - vectorBytes_ = value; - bitField0_ |= 0x00040000; - onChanged(); - return this; - } - /** - * bytes vector_bytes = 19; - * @return This builder for chaining. - */ - public Builder clearVectorBytes() { - bitField0_ = (bitField0_ & ~0x00040000); - vectorBytes_ = getDefaultInstance().getVectorBytes(); - onChanged(); - return this; - } - - private com.google.protobuf.ByteString idAsBytes_ = com.google.protobuf.ByteString.EMPTY; - /** - * bytes id_as_bytes = 20; - * @return The idAsBytes. - */ - @java.lang.Override - public com.google.protobuf.ByteString getIdAsBytes() { - return idAsBytes_; - } - /** - * bytes id_as_bytes = 20; - * @param value The idAsBytes to set. - * @return This builder for chaining. - */ - public Builder setIdAsBytes(com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - idAsBytes_ = value; - bitField0_ |= 0x00080000; - onChanged(); - return this; - } - /** - * bytes id_as_bytes = 20; - * @return This builder for chaining. - */ - public Builder clearIdAsBytes() { - bitField0_ = (bitField0_ & ~0x00080000); - idAsBytes_ = getDefaultInstance().getIdAsBytes(); - onChanged(); - return this; - } - - private double rerankScore_ ; - /** - * double rerank_score = 21; - * @return The rerankScore. - */ - @java.lang.Override - public double getRerankScore() { - return rerankScore_; - } - /** - * double rerank_score = 21; - * @param value The rerankScore to set. - * @return This builder for chaining. - */ - public Builder setRerankScore(double value) { - - rerankScore_ = value; - bitField0_ |= 0x00100000; - onChanged(); - return this; - } - /** - * double rerank_score = 21; - * @return This builder for chaining. - */ - public Builder clearRerankScore() { - bitField0_ = (bitField0_ & ~0x00100000); - rerankScore_ = 0D; - onChanged(); - return this; - } - - private boolean rerankScorePresent_ ; - /** - * bool rerank_score_present = 22; - * @return The rerankScorePresent. - */ - @java.lang.Override - public boolean getRerankScorePresent() { - return rerankScorePresent_; - } - /** - * bool rerank_score_present = 22; - * @param value The rerankScorePresent to set. - * @return This builder for chaining. - */ - public Builder setRerankScorePresent(boolean value) { - - rerankScorePresent_ = value; - bitField0_ |= 0x00200000; - onChanged(); - return this; - } - /** - * bool rerank_score_present = 22; - * @return This builder for chaining. - */ - public Builder clearRerankScorePresent() { - bitField0_ = (bitField0_ & ~0x00200000); - rerankScorePresent_ = false; - onChanged(); - return this; - } - - private java.util.List vectors_ = - java.util.Collections.emptyList(); - private void ensureVectorsIsMutable() { - if (!((bitField0_ & 0x00400000) != 0)) { - vectors_ = new java.util.ArrayList(vectors_); - bitField0_ |= 0x00400000; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_; - - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List getVectorsList() { - if (vectorsBuilder_ == null) { - return java.util.Collections.unmodifiableList(vectors_); - } else { - return vectorsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public int getVectorsCount() { - if (vectorsBuilder_ == null) { - return vectors_.size(); - } else { - return vectorsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) { - if (vectorsBuilder_ == null) { - return vectors_.get(index); - } else { - return vectorsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder setVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.set(index, value); - onChanged(); - } else { - vectorsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder setVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.set(index, builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.add(value); - onChanged(); - } else { - vectorsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) { - if (vectorsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureVectorsIsMutable(); - vectors_.add(index, value); - onChanged(); - } else { - vectorsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addVectors( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.add(index, builderForValue.build()); - onChanged(); - } else { - vectorsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder addAllVectors( - java.lang.Iterable values) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, vectors_); - onChanged(); - } else { - vectorsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder clearVectors() { - if (vectorsBuilder_ == null) { - vectors_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00400000); - onChanged(); - } else { - vectorsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public Builder removeVectors(int index) { - if (vectorsBuilder_ == null) { - ensureVectorsIsMutable(); - vectors_.remove(index); - onChanged(); - } else { - vectorsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder getVectorsBuilder( - int index) { - return getVectorsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( - int index) { - if (vectorsBuilder_ == null) { - return vectors_.get(index); } else { - return vectorsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List - getVectorsOrBuilderList() { - if (vectorsBuilder_ != null) { - return vectorsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(vectors_); - } - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() { - return getVectorsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder( - int index) { - return getVectorsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.Vectors vectors = 23; - */ - public java.util.List - getVectorsBuilderList() { - return getVectorsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> - getVectorsFieldBuilder() { - if (vectorsBuilder_ == null) { - vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder>( - vectors_, - ((bitField0_ & 0x00400000) != 0), - getParentForChildren(), - isClean()); - vectors_ = null; - } - return vectorsBuilder_; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.MetadataResult) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.MetadataResult) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public MetadataResult parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface PropertiesResultOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.PropertiesResult) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - java.util.List - getRefPropsList(); - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index); - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - int getRefPropsCount(); - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - java.util.List - getRefPropsOrBuilderList(); - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( - int index); - - /** - * string target_collection = 3; - * @return The targetCollection. - */ - java.lang.String getTargetCollection(); - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - com.google.protobuf.ByteString - getTargetCollectionBytes(); - - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return Whether the metadata field is set. - */ - boolean hasMetadata(); - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return The metadata. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata(); - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder(); - - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return Whether the nonRefProps field is set. - */ - boolean hasNonRefProps(); - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return The nonRefProps. - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getNonRefProps(); - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder(); - - /** - * bool ref_props_requested = 12; - * @return The refPropsRequested. - */ - boolean getRefPropsRequested(); - } - /** - * Protobuf type {@code weaviate.v1.PropertiesResult} - */ - public static final class PropertiesResult extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.PropertiesResult) - PropertiesResultOrBuilder { - private static final long serialVersionUID = 0L; - // Use PropertiesResult.newBuilder() to construct. - private PropertiesResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private PropertiesResult() { - refProps_ = java.util.Collections.emptyList(); - targetCollection_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new PropertiesResult(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder.class); - } - - private int bitField0_; - public static final int REF_PROPS_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private java.util.List refProps_; - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - @java.lang.Override - public java.util.List getRefPropsList() { - return refProps_; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - @java.lang.Override - public java.util.List - getRefPropsOrBuilderList() { - return refProps_; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - @java.lang.Override - public int getRefPropsCount() { - return refProps_.size(); - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index) { - return refProps_.get(index); - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( - int index) { - return refProps_.get(index); - } - - public static final int TARGET_COLLECTION_FIELD_NUMBER = 3; - @SuppressWarnings("serial") - private volatile java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 3; - * @return The targetCollection. - */ - @java.lang.Override - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } - } - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - public static final int METADATA_FIELD_NUMBER = 4; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult metadata_; - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return Whether the metadata field is set. - */ - @java.lang.Override - public boolean hasMetadata() { - return ((bitField0_ & 0x00000001) != 0); - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return The metadata. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - - public static final int NON_REF_PROPS_FIELD_NUMBER = 11; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties nonRefProps_; - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return Whether the nonRefProps field is set. - */ - @java.lang.Override - public boolean hasNonRefProps() { - return ((bitField0_ & 0x00000002) != 0); - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return The nonRefProps. - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getNonRefProps() { - return nonRefProps_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder() { - return nonRefProps_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; - } - - public static final int REF_PROPS_REQUESTED_FIELD_NUMBER = 12; - private boolean refPropsRequested_ = false; - /** - * bool ref_props_requested = 12; - * @return The refPropsRequested. - */ - @java.lang.Override - public boolean getRefPropsRequested() { - return refPropsRequested_; - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < refProps_.size(); i++) { - output.writeMessage(2, refProps_.get(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 3, targetCollection_); - } - if (((bitField0_ & 0x00000001) != 0)) { - output.writeMessage(4, getMetadata()); - } - if (((bitField0_ & 0x00000002) != 0)) { - output.writeMessage(11, getNonRefProps()); - } - if (refPropsRequested_ != false) { - output.writeBool(12, refPropsRequested_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < refProps_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, refProps_.get(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, targetCollection_); - } - if (((bitField0_ & 0x00000001) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(4, getMetadata()); - } - if (((bitField0_ & 0x00000002) != 0)) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(11, getNonRefProps()); - } - if (refPropsRequested_ != false) { - size += com.google.protobuf.CodedOutputStream - .computeBoolSize(12, refPropsRequested_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult) obj; - - if (!getRefPropsList() - .equals(other.getRefPropsList())) return false; - if (!getTargetCollection() - .equals(other.getTargetCollection())) return false; - if (hasMetadata() != other.hasMetadata()) return false; - if (hasMetadata()) { - if (!getMetadata() - .equals(other.getMetadata())) return false; - } - if (hasNonRefProps() != other.hasNonRefProps()) return false; - if (hasNonRefProps()) { - if (!getNonRefProps() - .equals(other.getNonRefProps())) return false; - } - if (getRefPropsRequested() - != other.getRefPropsRequested()) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getRefPropsCount() > 0) { - hash = (37 * hash) + REF_PROPS_FIELD_NUMBER; - hash = (53 * hash) + getRefPropsList().hashCode(); - } - hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; - hash = (53 * hash) + getTargetCollection().hashCode(); - if (hasMetadata()) { - hash = (37 * hash) + METADATA_FIELD_NUMBER; - hash = (53 * hash) + getMetadata().hashCode(); - } - if (hasNonRefProps()) { - hash = (37 * hash) + NON_REF_PROPS_FIELD_NUMBER; - hash = (53 * hash) + getNonRefProps().hashCode(); - } - hash = (37 * hash) + REF_PROPS_REQUESTED_FIELD_NUMBER; - hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( - getRefPropsRequested()); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.PropertiesResult} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.PropertiesResult) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.newBuilder() - private Builder() { - maybeForceBuilderInitialization(); - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - maybeForceBuilderInitialization(); - } - private void maybeForceBuilderInitialization() { - if (com.google.protobuf.GeneratedMessageV3 - .alwaysUseFieldBuilders) { - getRefPropsFieldBuilder(); - getMetadataFieldBuilder(); - getNonRefPropsFieldBuilder(); - } - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (refPropsBuilder_ == null) { - refProps_ = java.util.Collections.emptyList(); - } else { - refProps_ = null; - refPropsBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - targetCollection_ = ""; - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - nonRefProps_ = null; - if (nonRefPropsBuilder_ != null) { - nonRefPropsBuilder_.dispose(); - nonRefPropsBuilder_ = null; - } - refPropsRequested_ = false; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult result) { - if (refPropsBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - refProps_ = java.util.Collections.unmodifiableList(refProps_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.refProps_ = refProps_; - } else { - result.refProps_ = refPropsBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.targetCollection_ = targetCollection_; - } - int to_bitField0_ = 0; - if (((from_bitField0_ & 0x00000004) != 0)) { - result.metadata_ = metadataBuilder_ == null - ? metadata_ - : metadataBuilder_.build(); - to_bitField0_ |= 0x00000001; - } - if (((from_bitField0_ & 0x00000008) != 0)) { - result.nonRefProps_ = nonRefPropsBuilder_ == null - ? nonRefProps_ - : nonRefPropsBuilder_.build(); - to_bitField0_ |= 0x00000002; - } - if (((from_bitField0_ & 0x00000010) != 0)) { - result.refPropsRequested_ = refPropsRequested_; - } - result.bitField0_ |= to_bitField0_; - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()) return this; - if (refPropsBuilder_ == null) { - if (!other.refProps_.isEmpty()) { - if (refProps_.isEmpty()) { - refProps_ = other.refProps_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensureRefPropsIsMutable(); - refProps_.addAll(other.refProps_); - } - onChanged(); - } - } else { - if (!other.refProps_.isEmpty()) { - if (refPropsBuilder_.isEmpty()) { - refPropsBuilder_.dispose(); - refPropsBuilder_ = null; - refProps_ = other.refProps_; - bitField0_ = (bitField0_ & ~0x00000001); - refPropsBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getRefPropsFieldBuilder() : null; - } else { - refPropsBuilder_.addAllMessages(other.refProps_); - } - } - } - if (!other.getTargetCollection().isEmpty()) { - targetCollection_ = other.targetCollection_; - bitField0_ |= 0x00000002; - onChanged(); - } - if (other.hasMetadata()) { - mergeMetadata(other.getMetadata()); - } - if (other.hasNonRefProps()) { - mergeNonRefProps(other.getNonRefProps()); - } - if (other.getRefPropsRequested() != false) { - setRefPropsRequested(other.getRefPropsRequested()); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.parser(), - extensionRegistry); - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - refProps_.add(m); - } else { - refPropsBuilder_.addMessage(m); - } - break; - } // case 18 - case 26: { - targetCollection_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 26 - case 34: { - input.readMessage( - getMetadataFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000004; - break; - } // case 34 - case 90: { - input.readMessage( - getNonRefPropsFieldBuilder().getBuilder(), - extensionRegistry); - bitField0_ |= 0x00000008; - break; - } // case 90 - case 96: { - refPropsRequested_ = input.readBool(); - bitField0_ |= 0x00000010; - break; - } // case 96 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List refProps_ = - java.util.Collections.emptyList(); - private void ensureRefPropsIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - refProps_ = new java.util.ArrayList(refProps_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder> refPropsBuilder_; - - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public java.util.List getRefPropsList() { - if (refPropsBuilder_ == null) { - return java.util.Collections.unmodifiableList(refProps_); - } else { - return refPropsBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public int getRefPropsCount() { - if (refPropsBuilder_ == null) { - return refProps_.size(); - } else { - return refPropsBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index) { - if (refPropsBuilder_ == null) { - return refProps_.get(index); - } else { - return refPropsBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder setRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult value) { - if (refPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropsIsMutable(); - refProps_.set(index, value); - onChanged(); - } else { - refPropsBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder setRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - refProps_.set(index, builderForValue.build()); - onChanged(); - } else { - refPropsBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder addRefProps(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult value) { - if (refPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropsIsMutable(); - refProps_.add(value); - onChanged(); - } else { - refPropsBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder addRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult value) { - if (refPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensureRefPropsIsMutable(); - refProps_.add(index, value); - onChanged(); - } else { - refPropsBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder addRefProps( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - refProps_.add(builderForValue.build()); - onChanged(); - } else { - refPropsBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder addRefProps( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - refProps_.add(index, builderForValue.build()); - onChanged(); - } else { - refPropsBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder addAllRefProps( - java.lang.Iterable values) { - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, refProps_); - onChanged(); - } else { - refPropsBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder clearRefProps() { - if (refPropsBuilder_ == null) { - refProps_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - refPropsBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public Builder removeRefProps(int index) { - if (refPropsBuilder_ == null) { - ensureRefPropsIsMutable(); - refProps_.remove(index); - onChanged(); - } else { - refPropsBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder getRefPropsBuilder( - int index) { - return getRefPropsFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( - int index) { - if (refPropsBuilder_ == null) { - return refProps_.get(index); } else { - return refPropsBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public java.util.List - getRefPropsOrBuilderList() { - if (refPropsBuilder_ != null) { - return refPropsBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(refProps_); - } - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder addRefPropsBuilder() { - return getRefPropsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder addRefPropsBuilder( - int index) { - return getRefPropsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; - */ - public java.util.List - getRefPropsBuilderList() { - return getRefPropsFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder> - getRefPropsFieldBuilder() { - if (refPropsBuilder_ == null) { - refPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder>( - refProps_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - refProps_ = null; - } - return refPropsBuilder_; - } - - private java.lang.Object targetCollection_ = ""; - /** - * string target_collection = 3; - * @return The targetCollection. - */ - public java.lang.String getTargetCollection() { - java.lang.Object ref = targetCollection_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - targetCollection_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string target_collection = 3; - * @return The bytes for targetCollection. - */ - public com.google.protobuf.ByteString - getTargetCollectionBytes() { - java.lang.Object ref = targetCollection_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - targetCollection_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string target_collection = 3; - * @param value The targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollection( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - targetCollection_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string target_collection = 3; - * @return This builder for chaining. - */ - public Builder clearTargetCollection() { - targetCollection_ = getDefaultInstance().getTargetCollection(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string target_collection = 3; - * @param value The bytes for targetCollection to set. - * @return This builder for chaining. - */ - public Builder setTargetCollectionBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - targetCollection_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult metadata_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder> metadataBuilder_; - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return Whether the metadata field is set. - */ - public boolean hasMetadata() { - return ((bitField0_ & 0x00000004) != 0); - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - * @return The metadata. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult getMetadata() { - if (metadataBuilder_ == null) { - return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } else { - return metadataBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult value) { - if (metadataBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - metadata_ = value; - } else { - metadataBuilder_.setMessage(value); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public Builder setMetadata( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder builderForValue) { - if (metadataBuilder_ == null) { - metadata_ = builderForValue.build(); - } else { - metadataBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000004; - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult value) { - if (metadataBuilder_ == null) { - if (((bitField0_ & 0x00000004) != 0) && - metadata_ != null && - metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) { - getMetadataBuilder().mergeFrom(value); - } else { - metadata_ = value; - } - } else { - metadataBuilder_.mergeFrom(value); - } - if (metadata_ != null) { - bitField0_ |= 0x00000004; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public Builder clearMetadata() { - bitField0_ = (bitField0_ & ~0x00000004); - metadata_ = null; - if (metadataBuilder_ != null) { - metadataBuilder_.dispose(); - metadataBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder getMetadataBuilder() { - bitField0_ |= 0x00000004; - onChanged(); - return getMetadataFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { - if (metadataBuilder_ != null) { - return metadataBuilder_.getMessageOrBuilder(); - } else { - return metadata_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; - } - } - /** - * .weaviate.v1.MetadataResult metadata = 4; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder> - getMetadataFieldBuilder() { - if (metadataBuilder_ == null) { - metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResultOrBuilder>( - getMetadata(), - getParentForChildren(), - isClean()); - metadata_ = null; - } - return metadataBuilder_; - } - - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties nonRefProps_; - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> nonRefPropsBuilder_; - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return Whether the nonRefProps field is set. - */ - public boolean hasNonRefProps() { - return ((bitField0_ & 0x00000008) != 0); - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - * @return The nonRefProps. - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties getNonRefProps() { - if (nonRefPropsBuilder_ == null) { - return nonRefProps_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; - } else { - return nonRefPropsBuilder_.getMessage(); - } - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public Builder setNonRefProps(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (nonRefPropsBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - nonRefProps_ = value; - } else { - nonRefPropsBuilder_.setMessage(value); - } - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public Builder setNonRefProps( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder builderForValue) { - if (nonRefPropsBuilder_ == null) { - nonRefProps_ = builderForValue.build(); - } else { - nonRefPropsBuilder_.setMessage(builderForValue.build()); - } - bitField0_ |= 0x00000008; - onChanged(); - return this; - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public Builder mergeNonRefProps(io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties value) { - if (nonRefPropsBuilder_ == null) { - if (((bitField0_ & 0x00000008) != 0) && - nonRefProps_ != null && - nonRefProps_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance()) { - getNonRefPropsBuilder().mergeFrom(value); - } else { - nonRefProps_ = value; - } - } else { - nonRefPropsBuilder_.mergeFrom(value); - } - if (nonRefProps_ != null) { - bitField0_ |= 0x00000008; - onChanged(); - } - return this; - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public Builder clearNonRefProps() { - bitField0_ = (bitField0_ & ~0x00000008); - nonRefProps_ = null; - if (nonRefPropsBuilder_ != null) { - nonRefPropsBuilder_.dispose(); - nonRefPropsBuilder_ = null; - } - onChanged(); - return this; - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder getNonRefPropsBuilder() { - bitField0_ |= 0x00000008; - onChanged(); - return getNonRefPropsFieldBuilder().getBuilder(); - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder() { - if (nonRefPropsBuilder_ != null) { - return nonRefPropsBuilder_.getMessageOrBuilder(); - } else { - return nonRefProps_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; - } - } - /** - * .weaviate.v1.Properties non_ref_props = 11; - */ - private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder> - getNonRefPropsFieldBuilder() { - if (nonRefPropsBuilder_ == null) { - nonRefPropsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Properties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.PropertiesOrBuilder>( - getNonRefProps(), - getParentForChildren(), - isClean()); - nonRefProps_ = null; - } - return nonRefPropsBuilder_; - } - - private boolean refPropsRequested_ ; - /** - * bool ref_props_requested = 12; - * @return The refPropsRequested. - */ - @java.lang.Override - public boolean getRefPropsRequested() { - return refPropsRequested_; - } - /** - * bool ref_props_requested = 12; - * @param value The refPropsRequested to set. - * @return This builder for chaining. - */ - public Builder setRefPropsRequested(boolean value) { - - refPropsRequested_ = value; - bitField0_ |= 0x00000010; - onChanged(); - return this; - } - /** - * bool ref_props_requested = 12; - * @return This builder for chaining. - */ - public Builder clearRefPropsRequested() { - bitField0_ = (bitField0_ & ~0x00000010); - refPropsRequested_ = false; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.PropertiesResult) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.PropertiesResult) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public PropertiesResult parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - public interface RefPropertiesResultOrBuilder extends - // @@protoc_insertion_point(interface_extends:weaviate.v1.RefPropertiesResult) - com.google.protobuf.MessageOrBuilder { - - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - java.util.List - getPropertiesList(); - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties(int index); - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - int getPropertiesCount(); - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - java.util.List - getPropertiesOrBuilderList(); - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( - int index); - - /** - * string prop_name = 2; - * @return The propName. - */ - java.lang.String getPropName(); - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - com.google.protobuf.ByteString - getPropNameBytes(); - } - /** - * Protobuf type {@code weaviate.v1.RefPropertiesResult} - */ - public static final class RefPropertiesResult extends - com.google.protobuf.GeneratedMessageV3 implements - // @@protoc_insertion_point(message_implements:weaviate.v1.RefPropertiesResult) - RefPropertiesResultOrBuilder { - private static final long serialVersionUID = 0L; - // Use RefPropertiesResult.newBuilder() to construct. - private RefPropertiesResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); - } - private RefPropertiesResult() { - properties_ = java.util.Collections.emptyList(); - propName_ = ""; - } - - @java.lang.Override - @SuppressWarnings({"unused"}) - protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { - return new RefPropertiesResult(); - } - - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder.class); - } - - public static final int PROPERTIES_FIELD_NUMBER = 1; - @SuppressWarnings("serial") - private java.util.List properties_; - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public java.util.List getPropertiesList() { - return properties_; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public java.util.List - getPropertiesOrBuilderList() { - return properties_; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public int getPropertiesCount() { - return properties_.size(); - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties(int index) { - return properties_.get(index); - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( - int index) { - return properties_.get(index); - } - - public static final int PROP_NAME_FIELD_NUMBER = 2; - @SuppressWarnings("serial") - private volatile java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - @java.lang.Override - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - return (java.lang.String) ref; - } else { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - @java.lang.Override - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - - private byte memoizedIsInitialized = -1; - @java.lang.Override - public final boolean isInitialized() { - byte isInitialized = memoizedIsInitialized; - if (isInitialized == 1) return true; - if (isInitialized == 0) return false; - - memoizedIsInitialized = 1; - return true; - } - - @java.lang.Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { - for (int i = 0; i < properties_.size(); i++) { - output.writeMessage(1, properties_.get(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); - } - getUnknownFields().writeTo(output); - } - - @java.lang.Override - public int getSerializedSize() { - int size = memoizedSize; - if (size != -1) return size; - - size = 0; - for (int i = 0; i < properties_.size(); i++) { - size += com.google.protobuf.CodedOutputStream - .computeMessageSize(1, properties_.get(i)); - } - if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); - } - size += getUnknownFields().getSerializedSize(); - memoizedSize = size; - return size; - } - - @java.lang.Override - public boolean equals(final java.lang.Object obj) { - if (obj == this) { - return true; - } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult)) { - return super.equals(obj); - } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult) obj; - - if (!getPropertiesList() - .equals(other.getPropertiesList())) return false; - if (!getPropName() - .equals(other.getPropName())) return false; - if (!getUnknownFields().equals(other.getUnknownFields())) return false; - return true; - } - - @java.lang.Override - public int hashCode() { - if (memoizedHashCode != 0) { - return memoizedHashCode; - } - int hash = 41; - hash = (19 * hash) + getDescriptor().hashCode(); - if (getPropertiesCount() > 0) { - hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; - hash = (53 * hash) + getPropertiesList().hashCode(); - } - hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; - hash = (53 * hash) + getPropName().hashCode(); - hash = (29 * hash) + getUnknownFields().hashCode(); - memoizedHashCode = hash; - return hash; - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - java.nio.ByteBuffer data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - java.nio.ByteBuffer data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - com.google.protobuf.ByteString data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - com.google.protobuf.ByteString data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - return PARSER.parseFrom(data, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseDelimitedFrom( - java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - com.google.protobuf.CodedInputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input); - } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseWithIOException(PARSER, input, extensionRegistry); - } - - @java.lang.Override - public Builder newBuilderForType() { return newBuilder(); } - public static Builder newBuilder() { - return DEFAULT_INSTANCE.toBuilder(); - } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult prototype) { - return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); - } - @java.lang.Override - public Builder toBuilder() { - return this == DEFAULT_INSTANCE - ? new Builder() : new Builder().mergeFrom(this); - } - - @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - Builder builder = new Builder(parent); - return builder; - } - /** - * Protobuf type {@code weaviate.v1.RefPropertiesResult} - */ - public static final class Builder extends - com.google.protobuf.GeneratedMessageV3.Builder implements - // @@protoc_insertion_point(builder_implements:weaviate.v1.RefPropertiesResult) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder { - public static final com.google.protobuf.Descriptors.Descriptor - getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; - } - - @java.lang.Override - protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable - .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.Builder.class); - } - - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.newBuilder() - private Builder() { - - } - - private Builder( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { - super(parent); - - } - @java.lang.Override - public Builder clear() { - super.clear(); - bitField0_ = 0; - if (propertiesBuilder_ == null) { - properties_ = java.util.Collections.emptyList(); - } else { - properties_ = null; - propertiesBuilder_.clear(); - } - bitField0_ = (bitField0_ & ~0x00000001); - propName_ = ""; - return this; - } - - @java.lang.Override - public com.google.protobuf.Descriptors.Descriptor - getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance(); - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult result = buildPartial(); - if (!result.isInitialized()) { - throw newUninitializedMessageException(result); - } - return result; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult(this); - buildPartialRepeatedFields(result); - if (bitField0_ != 0) { buildPartial0(result); } - onBuilt(); - return result; - } - - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult result) { - if (propertiesBuilder_ == null) { - if (((bitField0_ & 0x00000001) != 0)) { - properties_ = java.util.Collections.unmodifiableList(properties_); - bitField0_ = (bitField0_ & ~0x00000001); - } - result.properties_ = properties_; - } else { - result.properties_ = propertiesBuilder_.build(); - } - } - - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult result) { - int from_bitField0_ = bitField0_; - if (((from_bitField0_ & 0x00000002) != 0)) { - result.propName_ = propName_; - } - } - - @java.lang.Override - public Builder clone() { - return super.clone(); - } - @java.lang.Override - public Builder setField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.setField(field, value); - } - @java.lang.Override - public Builder clearField( - com.google.protobuf.Descriptors.FieldDescriptor field) { - return super.clearField(field); - } - @java.lang.Override - public Builder clearOneof( - com.google.protobuf.Descriptors.OneofDescriptor oneof) { - return super.clearOneof(oneof); - } - @java.lang.Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - int index, java.lang.Object value) { - return super.setRepeatedField(field, index, value); - } - @java.lang.Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { - return super.addRepeatedField(field, value); - } - @java.lang.Override - public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult)other); - } else { - super.mergeFrom(other); - return this; - } - } - - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()) return this; - if (propertiesBuilder_ == null) { - if (!other.properties_.isEmpty()) { - if (properties_.isEmpty()) { - properties_ = other.properties_; - bitField0_ = (bitField0_ & ~0x00000001); - } else { - ensurePropertiesIsMutable(); - properties_.addAll(other.properties_); - } - onChanged(); - } - } else { - if (!other.properties_.isEmpty()) { - if (propertiesBuilder_.isEmpty()) { - propertiesBuilder_.dispose(); - propertiesBuilder_ = null; - properties_ = other.properties_; - bitField0_ = (bitField0_ & ~0x00000001); - propertiesBuilder_ = - com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? - getPropertiesFieldBuilder() : null; - } else { - propertiesBuilder_.addAllMessages(other.properties_); - } - } - } - if (!other.getPropName().isEmpty()) { - propName_ = other.propName_; - bitField0_ |= 0x00000002; - onChanged(); - } - this.mergeUnknownFields(other.getUnknownFields()); - onChanged(); - return this; - } - - @java.lang.Override - public final boolean isInitialized() { - return true; - } - - @java.lang.Override - public Builder mergeFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - if (extensionRegistry == null) { - throw new java.lang.NullPointerException(); - } - try { - boolean done = false; - while (!done) { - int tag = input.readTag(); - switch (tag) { - case 0: - done = true; - break; - case 10: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult m = - input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.parser(), - extensionRegistry); - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - properties_.add(m); - } else { - propertiesBuilder_.addMessage(m); - } - break; - } // case 10 - case 18: { - propName_ = input.readStringRequireUtf8(); - bitField0_ |= 0x00000002; - break; - } // case 18 - default: { - if (!super.parseUnknownField(input, extensionRegistry, tag)) { - done = true; // was an endgroup tag - } - break; - } // default: - } // switch (tag) - } // while (!done) - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.unwrapIOException(); - } finally { - onChanged(); - } // finally - return this; - } - private int bitField0_; - - private java.util.List properties_ = - java.util.Collections.emptyList(); - private void ensurePropertiesIsMutable() { - if (!((bitField0_ & 0x00000001) != 0)) { - properties_ = new java.util.ArrayList(properties_); - bitField0_ |= 0x00000001; - } - } - - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder> propertiesBuilder_; - - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public java.util.List getPropertiesList() { - if (propertiesBuilder_ == null) { - return java.util.Collections.unmodifiableList(properties_); - } else { - return propertiesBuilder_.getMessageList(); - } - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public int getPropertiesCount() { - if (propertiesBuilder_ == null) { - return properties_.size(); - } else { - return propertiesBuilder_.getCount(); - } - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult getProperties(int index) { - if (propertiesBuilder_ == null) { - return properties_.get(index); - } else { - return propertiesBuilder_.getMessage(index); - } - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder setProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensurePropertiesIsMutable(); - properties_.set(index, value); - onChanged(); - } else { - propertiesBuilder_.setMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder setProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - properties_.set(index, builderForValue.build()); - onChanged(); - } else { - propertiesBuilder_.setMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder addProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensurePropertiesIsMutable(); - properties_.add(value); - onChanged(); - } else { - propertiesBuilder_.addMessage(value); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder addProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult value) { - if (propertiesBuilder_ == null) { - if (value == null) { - throw new NullPointerException(); - } - ensurePropertiesIsMutable(); - properties_.add(index, value); - onChanged(); - } else { - propertiesBuilder_.addMessage(index, value); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder addProperties( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - properties_.add(builderForValue.build()); - onChanged(); - } else { - propertiesBuilder_.addMessage(builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder addProperties( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - properties_.add(index, builderForValue.build()); - onChanged(); - } else { - propertiesBuilder_.addMessage(index, builderForValue.build()); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder addAllProperties( - java.lang.Iterable values) { - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - com.google.protobuf.AbstractMessageLite.Builder.addAll( - values, properties_); - onChanged(); - } else { - propertiesBuilder_.addAllMessages(values); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder clearProperties() { - if (propertiesBuilder_ == null) { - properties_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000001); - onChanged(); - } else { - propertiesBuilder_.clear(); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public Builder removeProperties(int index) { - if (propertiesBuilder_ == null) { - ensurePropertiesIsMutable(); - properties_.remove(index); - onChanged(); - } else { - propertiesBuilder_.remove(index); - } - return this; - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder getPropertiesBuilder( - int index) { - return getPropertiesFieldBuilder().getBuilder(index); - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( - int index) { - if (propertiesBuilder_ == null) { - return properties_.get(index); } else { - return propertiesBuilder_.getMessageOrBuilder(index); - } - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public java.util.List - getPropertiesOrBuilderList() { - if (propertiesBuilder_ != null) { - return propertiesBuilder_.getMessageOrBuilderList(); - } else { - return java.util.Collections.unmodifiableList(properties_); - } - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder addPropertiesBuilder() { - return getPropertiesFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder addPropertiesBuilder( - int index) { - return getPropertiesFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()); - } - /** - * repeated .weaviate.v1.PropertiesResult properties = 1; - */ - public java.util.List - getPropertiesBuilderList() { - return getPropertiesFieldBuilder().getBuilderList(); - } - private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder> - getPropertiesFieldBuilder() { - if (propertiesBuilder_ == null) { - propertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesResultOrBuilder>( - properties_, - ((bitField0_ & 0x00000001) != 0), - getParentForChildren(), - isClean()); - properties_ = null; - } - return propertiesBuilder_; - } - - private java.lang.Object propName_ = ""; - /** - * string prop_name = 2; - * @return The propName. - */ - public java.lang.String getPropName() { - java.lang.Object ref = propName_; - if (!(ref instanceof java.lang.String)) { - com.google.protobuf.ByteString bs = - (com.google.protobuf.ByteString) ref; - java.lang.String s = bs.toStringUtf8(); - propName_ = s; - return s; - } else { - return (java.lang.String) ref; - } - } - /** - * string prop_name = 2; - * @return The bytes for propName. - */ - public com.google.protobuf.ByteString - getPropNameBytes() { - java.lang.Object ref = propName_; - if (ref instanceof String) { - com.google.protobuf.ByteString b = - com.google.protobuf.ByteString.copyFromUtf8( - (java.lang.String) ref); - propName_ = b; - return b; - } else { - return (com.google.protobuf.ByteString) ref; - } - } - /** - * string prop_name = 2; - * @param value The propName to set. - * @return This builder for chaining. - */ - public Builder setPropName( - java.lang.String value) { - if (value == null) { throw new NullPointerException(); } - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @return This builder for chaining. - */ - public Builder clearPropName() { - propName_ = getDefaultInstance().getPropName(); - bitField0_ = (bitField0_ & ~0x00000002); - onChanged(); - return this; - } - /** - * string prop_name = 2; - * @param value The bytes for propName to set. - * @return This builder for chaining. - */ - public Builder setPropNameBytes( - com.google.protobuf.ByteString value) { - if (value == null) { throw new NullPointerException(); } - checkByteStringIsUtf8(value); - propName_ = value; - bitField0_ |= 0x00000002; - onChanged(); - return this; - } - @java.lang.Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.setUnknownFields(unknownFields); - } - - @java.lang.Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { - return super.mergeUnknownFields(unknownFields); - } - - - // @@protoc_insertion_point(builder_scope:weaviate.v1.RefPropertiesResult) - } - - // @@protoc_insertion_point(class_scope:weaviate.v1.RefPropertiesResult) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult DEFAULT_INSTANCE; - static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult(); - } - - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstance() { - return DEFAULT_INSTANCE; - } - - private static final com.google.protobuf.Parser - PARSER = new com.google.protobuf.AbstractParser() { - @java.lang.Override - public RefPropertiesResult parsePartialFrom( - com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws com.google.protobuf.InvalidProtocolBufferException { - Builder builder = newBuilder(); - try { - builder.mergeFrom(input, extensionRegistry); - } catch (com.google.protobuf.InvalidProtocolBufferException e) { - throw e.setUnfinishedMessage(builder.buildPartial()); - } catch (com.google.protobuf.UninitializedMessageException e) { - throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); - } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(builder.buildPartial()); - } - return builder.buildPartial(); - } - }; - - public static com.google.protobuf.Parser parser() { - return PARSER; - } - - @java.lang.Override - public com.google.protobuf.Parser getParserForType() { - return PARSER; - } - - @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstanceForType() { - return DEFAULT_INSTANCE; - } - - } - - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_SearchRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_SearchRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GroupBy_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GroupBy_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_SortBy_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_SortBy_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_MetadataRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PropertiesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_RefPropertiesRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_Rerank_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_Rerank_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_SearchReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_SearchReply_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_RerankReply_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_RerankReply_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_GroupByResult_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_GroupByResult_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_SearchResult_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_SearchResult_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_MetadataResult_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_MetadataResult_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_PropertiesResult_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_weaviate_v1_RefPropertiesResult_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable; - - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; - } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\023v1/search_get.proto\022\013weaviate.v1\032\rv1/b" + - "ase.proto\032\024v1/base_search.proto\032\023v1/gene" + - "rative.proto\032\023v1/properties.proto\"\234\013\n\rSe" + - "archRequest\022\022\n\ncollection\030\001 \001(\t\022\016\n\006tenan" + - "t\030\n \001(\t\022=\n\021consistency_level\030\013 \001(\0162\035.wea" + - "viate.v1.ConsistencyLevelH\000\210\001\001\0227\n\nproper" + - "ties\030\024 \001(\0132\036.weaviate.v1.PropertiesReque" + - "stH\001\210\001\001\0223\n\010metadata\030\025 \001(\0132\034.weaviate.v1." + - "MetadataRequestH\002\210\001\001\022+\n\010group_by\030\026 \001(\0132\024" + - ".weaviate.v1.GroupByH\003\210\001\001\022\r\n\005limit\030\036 \001(\r" + - "\022\016\n\006offset\030\037 \001(\r\022\017\n\007autocut\030 \001(\r\022\r\n\005aft" + - "er\030! \001(\t\022$\n\007sort_by\030\" \003(\0132\023.weaviate.v1." + - "SortBy\022*\n\007filters\030( \001(\0132\024.weaviate.v1.Fi" + - "ltersH\004\210\001\001\022/\n\rhybrid_search\030) \001(\0132\023.weav" + - "iate.v1.HybridH\005\210\001\001\022+\n\013bm25_search\030* \001(\013" + - "2\021.weaviate.v1.BM25H\006\210\001\001\0221\n\013near_vector\030" + - "+ \001(\0132\027.weaviate.v1.NearVectorH\007\210\001\001\0221\n\013n" + - "ear_object\030, \001(\0132\027.weaviate.v1.NearObjec" + - "tH\010\210\001\001\0223\n\tnear_text\030- \001(\0132\033.weaviate.v1." + - "NearTextSearchH\t\210\001\001\0225\n\nnear_image\030. \001(\0132" + - "\034.weaviate.v1.NearImageSearchH\n\210\001\001\0225\n\nne" + - "ar_audio\030/ \001(\0132\034.weaviate.v1.NearAudioSe" + - "archH\013\210\001\001\0225\n\nnear_video\0300 \001(\0132\034.weaviate" + - ".v1.NearVideoSearchH\014\210\001\001\0225\n\nnear_depth\0301" + - " \001(\0132\034.weaviate.v1.NearDepthSearchH\r\210\001\001\022" + - "9\n\014near_thermal\0302 \001(\0132\036.weaviate.v1.Near" + - "ThermalSearchH\016\210\001\001\0221\n\010near_imu\0303 \001(\0132\032.w" + - "eaviate.v1.NearIMUSearchH\017\210\001\001\0226\n\ngenerat" + - "ive\030< \001(\0132\035.weaviate.v1.GenerativeSearch" + - "H\020\210\001\001\022(\n\006rerank\030= \001(\0132\023.weaviate.v1.Rera" + - "nkH\021\210\001\001\022\030\n\014uses_123_api\030d \001(\010B\002\030\001\022\030\n\014use" + - "s_125_api\030e \001(\010B\002\030\001\022\024\n\014uses_127_api\030f \001(" + - "\010B\024\n\022_consistency_levelB\r\n\013_propertiesB\013" + - "\n\t_metadataB\013\n\t_group_byB\n\n\010_filtersB\020\n\016" + - "_hybrid_searchB\016\n\014_bm25_searchB\016\n\014_near_" + - "vectorB\016\n\014_near_objectB\014\n\n_near_textB\r\n\013" + - "_near_imageB\r\n\013_near_audioB\r\n\013_near_vide" + - "oB\r\n\013_near_depthB\017\n\r_near_thermalB\013\n\t_ne" + - "ar_imuB\r\n\013_generativeB\t\n\007_rerank\"L\n\007Grou" + - "pBy\022\014\n\004path\030\001 \003(\t\022\030\n\020number_of_groups\030\002 " + - "\001(\005\022\031\n\021objects_per_group\030\003 \001(\005\")\n\006SortBy" + - "\022\021\n\tascending\030\001 \001(\010\022\014\n\004path\030\002 \003(\t\"\335\001\n\017Me" + - "tadataRequest\022\014\n\004uuid\030\001 \001(\010\022\016\n\006vector\030\002 " + - "\001(\010\022\032\n\022creation_time_unix\030\003 \001(\010\022\035\n\025last_" + - "update_time_unix\030\004 \001(\010\022\020\n\010distance\030\005 \001(\010" + - "\022\021\n\tcertainty\030\006 \001(\010\022\r\n\005score\030\007 \001(\010\022\025\n\rex" + - "plain_score\030\010 \001(\010\022\025\n\ris_consistent\030\t \001(\010" + - "\022\017\n\007vectors\030\n \003(\t\"\321\001\n\021PropertiesRequest\022" + - "\032\n\022non_ref_properties\030\001 \003(\t\0229\n\016ref_prope" + - "rties\030\002 \003(\0132!.weaviate.v1.RefPropertiesR" + - "equest\022?\n\021object_properties\030\003 \003(\0132$.weav" + - "iate.v1.ObjectPropertiesRequest\022$\n\034retur" + - "n_all_nonref_properties\030\013 \001(\010\"\213\001\n\027Object" + - "PropertiesRequest\022\021\n\tprop_name\030\001 \001(\t\022\034\n\024" + - "primitive_properties\030\002 \003(\t\022?\n\021object_pro" + - "perties\030\003 \003(\0132$.weaviate.v1.ObjectProper" + - "tiesRequest\"\261\001\n\024RefPropertiesRequest\022\032\n\022" + - "reference_property\030\001 \001(\t\0222\n\nproperties\030\002" + - " \001(\0132\036.weaviate.v1.PropertiesRequest\022.\n\010" + - "metadata\030\003 \001(\0132\034.weaviate.v1.MetadataReq" + - "uest\022\031\n\021target_collection\030\004 \001(\t\"8\n\006Reran" + - "k\022\020\n\010property\030\001 \001(\t\022\022\n\005query\030\002 \001(\tH\000\210\001\001B" + - "\010\n\006_query\"\256\002\n\013SearchReply\022\014\n\004took\030\001 \001(\002\022" + - "*\n\007results\030\002 \003(\0132\031.weaviate.v1.SearchRes" + - "ult\022*\n\031generative_grouped_result\030\003 \001(\tB\002" + - "\030\001H\000\210\001\001\0224\n\020group_by_results\030\004 \003(\0132\032.weav" + - "iate.v1.GroupByResult\022F\n\032generative_grou" + - "ped_results\030\005 \001(\0132\035.weaviate.v1.Generati" + - "veResultH\001\210\001\001B\034\n\032_generative_grouped_res" + - "ultB\035\n\033_generative_grouped_results\"\034\n\013Re" + - "rankReply\022\r\n\005score\030\001 \001(\001\"\351\002\n\rGroupByResu" + - "lt\022\014\n\004name\030\001 \001(\t\022\024\n\014min_distance\030\002 \001(\002\022\024" + - "\n\014max_distance\030\003 \001(\002\022\031\n\021number_of_object" + - "s\030\004 \001(\003\022*\n\007objects\030\005 \003(\0132\031.weaviate.v1.S" + - "earchResult\022-\n\006rerank\030\006 \001(\0132\030.weaviate.v" + - "1.RerankReplyH\000\210\001\001\0229\n\ngenerative\030\007 \001(\0132\034" + - ".weaviate.v1.GenerativeReplyB\002\030\001H\001\210\001\001\022=\n" + - "\021generative_result\030\010 \001(\0132\035.weaviate.v1.G" + - "enerativeResultH\002\210\001\001B\t\n\007_rerankB\r\n\013_gene" + - "rativeB\024\n\022_generative_result\"\267\001\n\014SearchR" + - "esult\0221\n\nproperties\030\001 \001(\0132\035.weaviate.v1." + - "PropertiesResult\022-\n\010metadata\030\002 \001(\0132\033.wea" + - "viate.v1.MetadataResult\0226\n\ngenerative\030\003 " + - "\001(\0132\035.weaviate.v1.GenerativeResultH\000\210\001\001B" + - "\r\n\013_generative\"\367\004\n\016MetadataResult\022\n\n\002id\030" + - "\001 \001(\t\022\022\n\006vector\030\002 \003(\002B\002\030\001\022\032\n\022creation_ti" + - "me_unix\030\003 \001(\003\022\"\n\032creation_time_unix_pres" + - "ent\030\004 \001(\010\022\035\n\025last_update_time_unix\030\005 \001(\003" + - "\022%\n\035last_update_time_unix_present\030\006 \001(\010\022" + - "\020\n\010distance\030\007 \001(\002\022\030\n\020distance_present\030\010 " + - "\001(\010\022\021\n\tcertainty\030\t \001(\002\022\031\n\021certainty_pres" + - "ent\030\n \001(\010\022\r\n\005score\030\013 \001(\002\022\025\n\rscore_presen" + - "t\030\014 \001(\010\022\025\n\rexplain_score\030\r \001(\t\022\035\n\025explai" + - "n_score_present\030\016 \001(\010\022\032\n\ris_consistent\030\017" + - " \001(\010H\000\210\001\001\022\026\n\ngenerative\030\020 \001(\tB\002\030\001\022\036\n\022gen" + - "erative_present\030\021 \001(\010B\002\030\001\022\035\n\025is_consiste" + - "nt_present\030\022 \001(\010\022\024\n\014vector_bytes\030\023 \001(\014\022\023" + - "\n\013id_as_bytes\030\024 \001(\014\022\024\n\014rerank_score\030\025 \001(" + - "\001\022\034\n\024rerank_score_present\030\026 \001(\010\022%\n\007vecto" + - "rs\030\027 \003(\0132\024.weaviate.v1.VectorsB\020\n\016_is_co" + - "nsistent\"\210\002\n\020PropertiesResult\0223\n\tref_pro" + - "ps\030\002 \003(\0132 .weaviate.v1.RefPropertiesResu" + - "lt\022\031\n\021target_collection\030\003 \001(\t\022-\n\010metadat" + - "a\030\004 \001(\0132\033.weaviate.v1.MetadataResult\022.\n\r" + - "non_ref_props\030\013 \001(\0132\027.weaviate.v1.Proper" + - "ties\022\033\n\023ref_props_requested\030\014 \001(\010J\004\010\001\020\002J" + - "\004\010\005\020\006J\004\010\006\020\007J\004\010\007\020\010J\004\010\010\020\tJ\004\010\t\020\nJ\004\010\n\020\013\"[\n\023R" + - "efPropertiesResult\0221\n\nproperties\030\001 \003(\0132\035" + - ".weaviate.v1.PropertiesResult\022\021\n\tprop_na" + - "me\030\002 \001(\tBs\n#io.weaviate.client.grpc.prot" + - "ocol.v1B\026WeaviateProtoSearchGetZ4github." + - "com/weaviate/weaviate/grpc/generated;pro" + - "tocolb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.getDescriptor(), - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.getDescriptor(), - }); - internal_static_weaviate_v1_SearchRequest_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_weaviate_v1_SearchRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_SearchRequest_descriptor, - new java.lang.String[] { "Collection", "Tenant", "ConsistencyLevel", "Properties", "Metadata", "GroupBy", "Limit", "Offset", "Autocut", "After", "SortBy", "Filters", "HybridSearch", "Bm25Search", "NearVector", "NearObject", "NearText", "NearImage", "NearAudio", "NearVideo", "NearDepth", "NearThermal", "NearImu", "Generative", "Rerank", "Uses123Api", "Uses125Api", "Uses127Api", "ConsistencyLevel", "Properties", "Metadata", "GroupBy", "Filters", "HybridSearch", "Bm25Search", "NearVector", "NearObject", "NearText", "NearImage", "NearAudio", "NearVideo", "NearDepth", "NearThermal", "NearImu", "Generative", "Rerank", }); - internal_static_weaviate_v1_GroupBy_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_weaviate_v1_GroupBy_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GroupBy_descriptor, - new java.lang.String[] { "Path", "NumberOfGroups", "ObjectsPerGroup", }); - internal_static_weaviate_v1_SortBy_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_weaviate_v1_SortBy_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_SortBy_descriptor, - new java.lang.String[] { "Ascending", "Path", }); - internal_static_weaviate_v1_MetadataRequest_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_MetadataRequest_descriptor, - new java.lang.String[] { "Uuid", "Vector", "CreationTimeUnix", "LastUpdateTimeUnix", "Distance", "Certainty", "Score", "ExplainScore", "IsConsistent", "Vectors", }); - internal_static_weaviate_v1_PropertiesRequest_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PropertiesRequest_descriptor, - new java.lang.String[] { "NonRefProperties", "RefProperties", "ObjectProperties", "ReturnAllNonrefProperties", }); - internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor = - getDescriptor().getMessageTypes().get(5); - internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor, - new java.lang.String[] { "PropName", "PrimitiveProperties", "ObjectProperties", }); - internal_static_weaviate_v1_RefPropertiesRequest_descriptor = - getDescriptor().getMessageTypes().get(6); - internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_RefPropertiesRequest_descriptor, - new java.lang.String[] { "ReferenceProperty", "Properties", "Metadata", "TargetCollection", }); - internal_static_weaviate_v1_Rerank_descriptor = - getDescriptor().getMessageTypes().get(7); - internal_static_weaviate_v1_Rerank_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_Rerank_descriptor, - new java.lang.String[] { "Property", "Query", "Query", }); - internal_static_weaviate_v1_SearchReply_descriptor = - getDescriptor().getMessageTypes().get(8); - internal_static_weaviate_v1_SearchReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_SearchReply_descriptor, - new java.lang.String[] { "Took", "Results", "GenerativeGroupedResult", "GroupByResults", "GenerativeGroupedResults", "GenerativeGroupedResult", "GenerativeGroupedResults", }); - internal_static_weaviate_v1_RerankReply_descriptor = - getDescriptor().getMessageTypes().get(9); - internal_static_weaviate_v1_RerankReply_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_RerankReply_descriptor, - new java.lang.String[] { "Score", }); - internal_static_weaviate_v1_GroupByResult_descriptor = - getDescriptor().getMessageTypes().get(10); - internal_static_weaviate_v1_GroupByResult_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_GroupByResult_descriptor, - new java.lang.String[] { "Name", "MinDistance", "MaxDistance", "NumberOfObjects", "Objects", "Rerank", "Generative", "GenerativeResult", "Rerank", "Generative", "GenerativeResult", }); - internal_static_weaviate_v1_SearchResult_descriptor = - getDescriptor().getMessageTypes().get(11); - internal_static_weaviate_v1_SearchResult_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_SearchResult_descriptor, - new java.lang.String[] { "Properties", "Metadata", "Generative", "Generative", }); - internal_static_weaviate_v1_MetadataResult_descriptor = - getDescriptor().getMessageTypes().get(12); - internal_static_weaviate_v1_MetadataResult_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_MetadataResult_descriptor, - new java.lang.String[] { "Id", "Vector", "CreationTimeUnix", "CreationTimeUnixPresent", "LastUpdateTimeUnix", "LastUpdateTimeUnixPresent", "Distance", "DistancePresent", "Certainty", "CertaintyPresent", "Score", "ScorePresent", "ExplainScore", "ExplainScorePresent", "IsConsistent", "Generative", "GenerativePresent", "IsConsistentPresent", "VectorBytes", "IdAsBytes", "RerankScore", "RerankScorePresent", "Vectors", "IsConsistent", }); - internal_static_weaviate_v1_PropertiesResult_descriptor = - getDescriptor().getMessageTypes().get(13); - internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_PropertiesResult_descriptor, - new java.lang.String[] { "RefProps", "TargetCollection", "Metadata", "NonRefProps", "RefPropsRequested", }); - internal_static_weaviate_v1_RefPropertiesResult_descriptor = - getDescriptor().getMessageTypes().get(14); - internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_weaviate_v1_RefPropertiesResult_descriptor, - new java.lang.String[] { "Properties", "PropName", }); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.getDescriptor(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.getDescriptor(); - } - - // @@protoc_insertion_point(outer_class_scope) -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/Aliases.java b/src/main/java/io/weaviate/client/v1/aliases/Aliases.java deleted file mode 100644 index aac69243b..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/Aliases.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.aliases; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.aliases.api.AliasAllGetter; -import io.weaviate.client.v1.aliases.api.AliasCreator; -import io.weaviate.client.v1.aliases.api.AliasDeleter; -import io.weaviate.client.v1.aliases.api.AliasGetter; -import io.weaviate.client.v1.aliases.api.AliasUpdater; - -public class Aliases { - private final Config config; - private final HttpClient httpClient; - - public Aliases(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public AliasCreator creator() { - return new AliasCreator(httpClient, config); - } - - public AliasGetter getter() { - return new AliasGetter(httpClient, config); - } - - public AliasAllGetter allGetter() { - return new AliasAllGetter(httpClient, config); - } - - public AliasDeleter deleter() { - return new AliasDeleter(httpClient, config); - } - - public AliasUpdater updater() { - return new AliasUpdater(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/api/AliasAllGetter.java b/src/main/java/io/weaviate/client/v1/aliases/api/AliasAllGetter.java deleted file mode 100644 index 92d59652d..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/api/AliasAllGetter.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.client.v1.aliases.api; - -import java.util.List; -import java.util.Map; -import java.util.function.Function; -import java.util.stream.Collectors; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.aliases.api.AliasAllGetter.ResponseBody; -import io.weaviate.client.v1.aliases.model.Alias; - -public class AliasAllGetter extends BaseClient implements ClientResult> { - private String className; - - public AliasAllGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - /** List aliases defined for this class. */ - public AliasAllGetter withClassName(String className) { - this.className = className; - return this; - } - - static class ResponseBody { - List aliases; - } - - @Override - public Result> run() { - String path = "/aliases" + (className != null ? "?class=" + className : ""); - Response resp = sendGetRequest(path, ResponseBody.class); - if (resp.getErrors() != null) { - return new Result<>(resp, null); - } - Map aliases = resp.getBody().aliases.stream() - .collect(Collectors.toMap(Alias::getAlias, Function.identity())); - return new Result<>(resp, aliases); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/api/AliasCreator.java b/src/main/java/io/weaviate/client/v1/aliases/api/AliasCreator.java deleted file mode 100644 index aa123c392..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/api/AliasCreator.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.aliases.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.aliases.model.Alias; - -public class AliasCreator extends BaseClient implements ClientResult { - private String className; - private String alias; - - public AliasCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AliasCreator withClassName(String className) { - this.className = className; - return this; - } - - public AliasCreator withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Result run() { - Response resp = sendPostRequest("/aliases", new Alias(className, alias), Void.class); - return Result.voidToBoolean(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/api/AliasDeleter.java b/src/main/java/io/weaviate/client/v1/aliases/api/AliasDeleter.java deleted file mode 100644 index 0bed20b3b..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/api/AliasDeleter.java +++ /dev/null @@ -1,27 +0,0 @@ -package io.weaviate.client.v1.aliases.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class AliasDeleter extends BaseClient implements ClientResult { - private String alias; - - public AliasDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AliasDeleter withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Result run() { - Response resp = sendDeleteRequest("/aliases/" + alias, null, Void.class); - return Result.voidToBoolean(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/api/AliasGetter.java b/src/main/java/io/weaviate/client/v1/aliases/api/AliasGetter.java deleted file mode 100644 index b3a8f9aca..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/api/AliasGetter.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.aliases.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.aliases.model.Alias; - -public class AliasGetter extends BaseClient implements ClientResult { - private String alias; - - public AliasGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AliasGetter withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Result run() { - return new Result<>(sendGetRequest("/aliases/" + alias, Alias.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/api/AliasUpdater.java b/src/main/java/io/weaviate/client/v1/aliases/api/AliasUpdater.java deleted file mode 100644 index 8eea4a90f..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/api/AliasUpdater.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.weaviate.client.v1.aliases.api; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class AliasUpdater extends BaseClient implements ClientResult { - private String className; - private String alias; - - public AliasUpdater(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AliasUpdater withAlias(String alias) { - this.alias = alias; - return this; - } - - public AliasUpdater withNewClassName(String className) { - this.className = className; - return this; - } - - class Body { - @SerializedName("class") - String className = AliasUpdater.this.className; - } - - @Override - public Result run() { - Response resp = sendPutRequest("/aliases/" + alias, new Body(), Void.class); - return Result.voidToBoolean(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/aliases/model/Alias.java b/src/main/java/io/weaviate/client/v1/aliases/model/Alias.java deleted file mode 100644 index b6c99816f..000000000 --- a/src/main/java/io/weaviate/client/v1/aliases/model/Alias.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.aliases.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - -@Getter -@RequiredArgsConstructor -@EqualsAndHashCode -public class Alias { - @SerializedName("class") - private final String className; - @SerializedName("alias") - private final String alias; -} diff --git a/src/main/java/io/weaviate/client/v1/async/WeaviateAsyncClient.java b/src/main/java/io/weaviate/client/v1/async/WeaviateAsyncClient.java deleted file mode 100644 index d341bd74f..000000000 --- a/src/main/java/io/weaviate/client/v1/async/WeaviateAsyncClient.java +++ /dev/null @@ -1,122 +0,0 @@ -package io.weaviate.client.v1.async; - -import java.util.Optional; -import java.util.concurrent.ExecutionException; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.io.CloseMode; - -import io.weaviate.client.Config; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.AsyncHttpClient; -import io.weaviate.client.base.util.DbVersionProvider; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.async.aliases.Aliases; -import io.weaviate.client.v1.async.backup.Backup; -import io.weaviate.client.v1.async.batch.Batch; -import io.weaviate.client.v1.async.classifications.Classifications; -import io.weaviate.client.v1.async.cluster.Cluster; -import io.weaviate.client.v1.async.data.Data; -import io.weaviate.client.v1.async.graphql.GraphQL; -import io.weaviate.client.v1.async.groups.Groups; -import io.weaviate.client.v1.async.misc.Misc; -import io.weaviate.client.v1.async.rbac.Roles; -import io.weaviate.client.v1.async.schema.Schema; -import io.weaviate.client.v1.async.users.Users; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.misc.model.Meta; - -public class WeaviateAsyncClient implements AutoCloseable { - private final Config config; - private final CloseableHttpAsyncClient client; - private final DbVersionSupport dbVersionSupport; - private final GrpcVersionSupport grpcVersionSupport; - private final AccessTokenProvider tokenProvider; - - public WeaviateAsyncClient(Config config, AccessTokenProvider tokenProvider) { - this.config = config; - this.client = AsyncHttpClient.create(config); - // auto start the client - this.start(); - // init the db version provider and get the version info - DbVersionProvider dbVersionProvider = initDbVersionProvider(); - this.dbVersionSupport = new DbVersionSupport(dbVersionProvider); - this.grpcVersionSupport = new GrpcVersionSupport(dbVersionProvider); - this.tokenProvider = tokenProvider; - } - - public Misc misc() { - return new Misc(client, config, tokenProvider); - } - - public Schema schema() { - return new Schema(client, config, tokenProvider, dbVersionSupport); - } - - public Data data() { - return new Data(client, config, tokenProvider, dbVersionSupport); - } - - public Batch batch() { - return new Batch(client, config, dbVersionSupport, grpcVersionSupport, tokenProvider, data()); - } - - public Cluster cluster() { - return new Cluster(client, config, tokenProvider); - } - - public Classifications classifications() { - return new Classifications(client, config, tokenProvider); - } - - public Backup backup() { - return new Backup(client, config, tokenProvider); - } - - public GraphQL graphQL() { - return new GraphQL(client, config, tokenProvider); - } - - public Roles roles() { - return new Roles(client, config, tokenProvider); - } - - public Users users() { - return new Users(client, config, tokenProvider); - } - - public Groups groups() { - return new Groups(client, config, tokenProvider); - } - - public Aliases alias() { - return new Aliases(client, config, tokenProvider); - } - - private DbVersionProvider initDbVersionProvider() { - DbVersionProvider.VersionGetter getter = () -> Optional.ofNullable(this.getMeta()) - .filter(result -> !result.hasErrors()) - .map(result -> result.getResult().getVersion()); - - return new DbVersionProvider(getter); - } - - private Result getMeta() { - try { - return new Misc(client, config, tokenProvider).metaGetter().run().get(); - } catch (InterruptedException | ExecutionException e) { - // we can't connect to Weaviate, metaResult will be null - return null; - } - } - - private void start() { - this.client.start(); - } - - @Override - public void close() { - this.client.close(CloseMode.GRACEFUL); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/Aliases.java b/src/main/java/io/weaviate/client/v1/async/aliases/Aliases.java deleted file mode 100644 index ee56fc2b6..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/Aliases.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.async.aliases; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.aliases.api.AliasAllGetter; -import io.weaviate.client.v1.async.aliases.api.AliasCreator; -import io.weaviate.client.v1.async.aliases.api.AliasDeleter; -import io.weaviate.client.v1.async.aliases.api.AliasGetter; -import io.weaviate.client.v1.async.aliases.api.AliasUpdater; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Aliases { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public AliasCreator creator() { - return new AliasCreator(client, config, tokenProvider); - } - - public AliasGetter getter() { - return new AliasGetter(client, config, tokenProvider); - } - - public AliasAllGetter allGetter() { - return new AliasAllGetter(client, config, tokenProvider); - } - - public AliasDeleter deleter() { - return new AliasDeleter(client, config, tokenProvider); - } - - public AliasUpdater updater() { - return new AliasUpdater(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasAllGetter.java b/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasAllGetter.java deleted file mode 100644 index 76abe57f6..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasAllGetter.java +++ /dev/null @@ -1,58 +0,0 @@ -package io.weaviate.client.v1.async.aliases.api; - -import java.util.List; -import java.util.Map; -import java.util.concurrent.Future; -import java.util.function.Function; -import java.util.stream.Collectors; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AliasAllGetter extends AsyncBaseClient> - implements AsyncClientResult> { - private String className; - - public AliasAllGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - /** List aliases defined for this class. */ - public AliasAllGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - String path = "/aliases" + (className != null ? "?class=" + className : ""); - return sendGetRequest(path, callback, new ResponseParser>() { - - class ResponseBody { - List aliases; - } - - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, ResponseBody.class); - if (resp.getErrors() != null) { - return new Result<>(resp, null); - } - Map aliases = resp.getBody().aliases.stream() - .collect(Collectors.toMap(Alias::getAlias, Function.identity())); - return new Result<>(resp, aliases); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasCreator.java b/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasCreator.java deleted file mode 100644 index cbfa5d4a4..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasCreator.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.v1.async.aliases.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AliasCreator extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String alias; - - public AliasCreator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AliasCreator withClassName(String className) { - this.className = className; - return this; - } - - public AliasCreator withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/aliases", new Alias(className, alias), - callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasDeleter.java b/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasDeleter.java deleted file mode 100644 index 0180e5add..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasDeleter.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.aliases.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AliasDeleter extends AsyncBaseClient implements AsyncClientResult { - private String alias; - - public AliasDeleter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AliasDeleter withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendDeleteRequest("/aliases/" + alias, null, - callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasGetter.java b/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasGetter.java deleted file mode 100644 index bc06fd843..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasGetter.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.aliases.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AliasGetter extends AsyncBaseClient implements AsyncClientResult { - private String alias; - - public AliasGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AliasGetter withAlias(String alias) { - this.alias = alias; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/aliases/" + alias, Alias.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasUpdater.java b/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasUpdater.java deleted file mode 100644 index 06e373e43..000000000 --- a/src/main/java/io/weaviate/client/v1/async/aliases/api/AliasUpdater.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.async.aliases.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AliasUpdater extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String alias; - - public AliasUpdater(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AliasUpdater withAlias(String alias) { - this.alias = alias; - return this; - } - - public AliasUpdater withNewClassName(String className) { - this.className = className; - return this; - } - - class Body { - @SerializedName("class") - String className = AliasUpdater.this.className; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPutRequest("/aliases/" + alias, new Body(), - callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/Backup.java b/src/main/java/io/weaviate/client/v1/async/backup/Backup.java deleted file mode 100644 index 258e43460..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/Backup.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.async.backup; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.backup.api.BackupCanceler; -import io.weaviate.client.v1.async.backup.api.BackupCreateStatusGetter; -import io.weaviate.client.v1.async.backup.api.BackupCreator; -import io.weaviate.client.v1.async.backup.api.BackupGetter; -import io.weaviate.client.v1.async.backup.api.BackupRestoreStatusGetter; -import io.weaviate.client.v1.async.backup.api.BackupRestorer; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import java.util.concurrent.Executor; - -@RequiredArgsConstructor -public class Backup { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public BackupCreator creator() { - return creator(null); - } - - public BackupCreator creator(Executor executor) { - return new BackupCreator(client, config, tokenProvider, createStatusGetter(), executor); - } - - public BackupCreateStatusGetter createStatusGetter() { - return new BackupCreateStatusGetter(client, config, tokenProvider); - } - - public BackupRestorer restorer() { - return restorer(null); - } - - public BackupRestorer restorer(Executor executor) { - return new BackupRestorer(client, config, tokenProvider, restoreStatusGetter(), executor); - } - - public BackupRestoreStatusGetter restoreStatusGetter() { - return new BackupRestoreStatusGetter(client, config, tokenProvider); - } - - public BackupCanceler canceler() { - return new BackupCanceler(client, config, tokenProvider); - } - - public BackupGetter getter() { // TODO: add test - return new BackupGetter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCanceler.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCanceler.java deleted file mode 100644 index 1d2fb9318..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCanceler.java +++ /dev/null @@ -1,75 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -/** - * BackupCanceler can cancel an in-progress backup by ID. - * - *

- * Canceling backups which have successfully completed before being interrupted is not supported and will result in an error. - */ -public class BackupCanceler extends AsyncBaseClient - implements AsyncClientResult { - - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - - public BackupCanceler(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public BackupCanceler withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCanceler withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupCanceler withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupCanceler withPath(String path) { - this.backupPath = path; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/backups/%s/%s", UrlEncoder.encodePathParam(backend), UrlEncoder.encodePathParam(backupId)); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return sendDeleteRequest(path, null, Void.class, callback); - } -} - diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreateStatusGetter.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreateStatusGetter.java deleted file mode 100644 index 32c65572b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreateStatusGetter.java +++ /dev/null @@ -1,68 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; - -public class BackupCreateStatusGetter extends AsyncBaseClient - implements AsyncClientResult { - - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - public BackupCreateStatusGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - - public BackupCreateStatusGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCreateStatusGetter withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupCreateStatusGetter withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupCreateStatusGetter withPath(String path) { - this.backupPath = path; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/backups/%s/%s", UrlEncoder.encodePathParam(backend), UrlEncoder.encodePathParam(backupId)); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return sendGetRequest(path, BackupCreateStatusResponse.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreator.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreator.java deleted file mode 100644 index b09072f76..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupCreator.java +++ /dev/null @@ -1,256 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import com.google.gson.annotations.SerializedName; -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.util.Futures; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; -import io.weaviate.client.v1.backup.model.CreateStatus; -import lombok.Builder; -import lombok.Getter; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import java.util.List; -import java.util.Optional; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; - -public class BackupCreator extends AsyncBaseClient - implements AsyncClientResult { - - private static final long WAIT_INTERVAL = 1000; - - private final BackupCreateStatusGetter statusGetter; - private String[] includeClassNames; - private String[] excludeClassNames; - private String backend; - private String backupId; - private BackupCreateConfig config; - private boolean waitForCompletion; - private final Executor executor; - - - public BackupCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, BackupCreateStatusGetter statusGetter, Executor executor) { - super(client, config, tokenProvider); - this.statusGetter = statusGetter; - this.executor = executor; - } - - - public BackupCreator withIncludeClassNames(String... classNames) { - this.includeClassNames = classNames; - return this; - } - - public BackupCreator withExcludeClassNames(String... classNames) { - this.excludeClassNames = classNames; - return this; - } - - public BackupCreator withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCreator withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupCreator withConfig(BackupCreateConfig config) { - this.config = config; - return this; - } - - public BackupCreator withWaitForCompletion(boolean waitForCompletion) { - this.waitForCompletion = waitForCompletion; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - if (waitForCompletion) { - return createAndWaitForCompletion(callback); - } - return create(callback); - } - - private Future> create(FutureCallback> callback) { - BackupCreate payload = BackupCreate.builder() - .id(backupId) - .config(config) - .include(includeClassNames) - .exclude(excludeClassNames) - .build(); - String path = String.format("/backups/%s", UrlEncoder.encodePathParam(backend)); - return sendPostRequest(path, payload, BackupCreateResponse.class, callback); - } - - private Future> createAndWaitForCompletion(FutureCallback> callback) { - CompletableFuture> future = new CompletableFuture<>(); - FutureCallback> internalCallback = new FutureCallback>() { - @Override - public void completed(Result backupCreateResult) { - future.complete(backupCreateResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - future.cancel(true); - if (callback != null) { - callback.cancelled(); // TODO:AL propagate cancel() call from future to completable future - } - } - }; - - create(internalCallback); - - return future.thenCompose(createResult -> { - if (createResult.hasErrors()) { - return CompletableFuture.completedFuture(createResult); - } - return getStatusRecursively(backend, backupId, createResult); - }) - .whenComplete((createResult, throwable) -> { - if (callback != null) { - if (throwable != null) { - callback.failed((Exception) throwable); - } else { - callback.completed(createResult); - } - } - }); - } - - private CompletableFuture> getStatus(String backend, String backupId) { - CompletableFuture> future = new CompletableFuture<>(); - statusGetter.withBackend(backend).withBackupId(backupId) - .run(new FutureCallback>() { - @Override - public void completed(Result createStatusResult) { - future.complete(createStatusResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - return future; - } - - private CompletableFuture> getStatusRecursively(String backend, String backupId, - Result createResult) { - return Futures.thenComposeAsync(getStatus(backend, backupId), createStatusResult -> { - boolean isRunning = Optional.of(createStatusResult) - .filter(r -> !r.hasErrors()) - .map(Result::getResult) - .map(BackupCreateStatusResponse::getStatus) - .filter(status -> { - switch (status) { - case CreateStatus.SUCCESS: - case CreateStatus.FAILED: - return false; - default: - return true; - } - }) - .isPresent(); - - if (isRunning) { - try { - return Futures.supplyDelayed(() -> getStatusRecursively(backend, backupId, createResult), WAIT_INTERVAL, executor); - } catch (InterruptedException e) { - throw new CompletionException(e); - } - } - return CompletableFuture.completedFuture(merge(createStatusResult, createResult)); - }, executor); - } - - private Result merge(Result createStatusResult, - Result createResult) { - BackupCreateStatusResponse createStatusResponse = createStatusResult.getResult(); - BackupCreateResponse createResponse = createResult.getResult(); - - BackupCreateResponse merged = null; - int statusCode = HttpStatus.SC_OK; - WeaviateErrorResponse errorResponse = null; - - if (createStatusResponse != null) { - merged = new BackupCreateResponse(); - - merged.setId(createStatusResponse.getId()); - merged.setBackend(createStatusResponse.getBackend()); - merged.setPath(createStatusResponse.getPath()); - merged.setStatus(createStatusResponse.getStatus()); - merged.setError(createStatusResponse.getError()); - merged.setClassNames(createResponse.getClassNames()); - } - if (createStatusResult.hasErrors()) { - WeaviateError error = createStatusResult.getError(); - statusCode = error.getStatusCode(); - List messages = error.getMessages(); - - errorResponse = WeaviateErrorResponse.builder() - .code(statusCode) - .error(messages) - .build(); - } - - return new Result<>(statusCode, merged, errorResponse); - } - - - @Getter - @Builder - private static class BackupCreate { - String id; - String[] include; - String[] exclude; - BackupCreateConfig config; - } - - @Getter - @Builder - public static class BackupCreateConfig { - @SerializedName("CPUPercentage") - Integer cpuPercentage; - @SerializedName("ChunkSize") - Integer chunkSize; - @SerializedName("CompressionLevel") - String compressionLevel; - @SerializedName("Bucket") - String bucket; - @SerializedName("Path") - String path; - } - - public interface BackupCompression { - String DEFAULT_COMPRESSION = "DefaultCompression"; - String BEST_SPEED = "BestSpeed"; - String BEST_COMPRESSION = "BestCompression"; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupGetter.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupGetter.java deleted file mode 100644 index f1d2ae45c..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupGetter.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public class BackupGetter extends AsyncBaseClient - implements AsyncClientResult { - - private String backend; - - - public BackupGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - - public BackupGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/backups/%s", UrlEncoder.encodePathParam(backend)); - return sendGetRequest(path, BackupCreateResponse[].class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestoreStatusGetter.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestoreStatusGetter.java deleted file mode 100644 index e1331cb09..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestoreStatusGetter.java +++ /dev/null @@ -1,68 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; - -public class BackupRestoreStatusGetter extends AsyncBaseClient - implements AsyncClientResult { - - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - public BackupRestoreStatusGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - - public BackupRestoreStatusGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupRestoreStatusGetter withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupRestoreStatusGetter withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupRestoreStatusGetter withPath(String path) { - this.backupPath = path; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend), UrlEncoder.encodePathParam(backupId)); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return sendGetRequest(path, BackupRestoreStatusResponse.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java b/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java deleted file mode 100644 index 5a7eac7af..000000000 --- a/src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java +++ /dev/null @@ -1,264 +0,0 @@ -package io.weaviate.client.v1.async.backup.api; - -import java.util.List; -import java.util.Optional; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.util.Futures; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.backup.model.BackupRestoreResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; -import io.weaviate.client.v1.backup.model.RbacRestoreOption; -import io.weaviate.client.v1.backup.model.RestoreStatus; -import lombok.Builder; -import lombok.Getter; - -public class BackupRestorer extends AsyncBaseClient - implements AsyncClientResult { - - private static final long WAIT_INTERVAL = 1000; - - private final BackupRestoreStatusGetter statusGetter; - private String[] includeClassNames; - private String[] excludeClassNames; - private String backend; - private String backupId; - private Boolean overwriteAlias; - private BackupRestoreConfig config; - private boolean waitForCompletion; - private final Executor executor; - - public BackupRestorer(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, - BackupRestoreStatusGetter statusGetter, Executor executor) { - super(client, config, tokenProvider); - this.statusGetter = statusGetter; - this.executor = executor; - } - - public BackupRestorer withIncludeClassNames(String... classNames) { - this.includeClassNames = classNames; - return this; - } - - public BackupRestorer withExcludeClassNames(String... classNames) { - this.excludeClassNames = classNames; - return this; - } - - public BackupRestorer withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupRestorer withConfig(BackupRestoreConfig config) { - this.config = config; - return this; - } - - public BackupRestorer withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupRestorer withWaitForCompletion(boolean waitForCompletion) { - this.waitForCompletion = waitForCompletion; - return this; - } - - public BackupRestorer withOverwriteAlias(boolean overwriteAlias) { - this.overwriteAlias = overwriteAlias; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (waitForCompletion) { - return restoreAndWaitForCompletion(callback); - } - return restore(callback); - } - - private Future> restore(FutureCallback> callback) { - BackupRestore payload = BackupRestore.builder() - .config(BackupRestoreConfig.builder().build()) - .include(includeClassNames) - .exclude(excludeClassNames) - .overwriteAlias(overwriteAlias) - .config(config) - .build(); - String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend), - UrlEncoder.encodePathParam(backupId)); - return sendPostRequest(path, payload, BackupRestoreResponse.class, callback); - } - - private Future> restoreAndWaitForCompletion( - FutureCallback> callback) { - CompletableFuture> future = new CompletableFuture<>(); - FutureCallback> internalCallback = new FutureCallback>() { - @Override - public void completed(Result backupRestoreResult) { - future.complete(backupRestoreResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - future.cancel(true); - if (callback != null) { - callback.cancelled(); // TODO:AL propagate cancel() call from future to completable future - } - } - }; - - restore(internalCallback); - - return future.thenCompose(restoreResult -> { - if (restoreResult.hasErrors()) { - return CompletableFuture.completedFuture(restoreResult); - } - return getStatusRecursively(backend, backupId, restoreResult); - }) - .whenComplete((restoreResult, throwable) -> { - if (callback != null) { - if (throwable != null) { - callback.failed((Exception) throwable); - } else { - callback.completed(restoreResult); - } - } - }); - } - - private CompletableFuture> getStatus(String backend, String backupId) { - CompletableFuture> future = new CompletableFuture<>(); - statusGetter.withBackend(backend).withBackupId(backupId) - .run(new FutureCallback>() { - @Override - public void completed(Result createStatusResult) { - future.complete(createStatusResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - return future; - } - - private CompletableFuture> getStatusRecursively(String backend, String backupId, - Result restoreResult) { - return Futures.thenComposeAsync(getStatus(backend, backupId), restoreStatusResult -> { - boolean isRunning = Optional.of(restoreStatusResult) - .filter(r -> !r.hasErrors()) - .map(Result::getResult) - .map(BackupRestoreStatusResponse::getStatus) - .filter(status -> { - switch (status) { - case RestoreStatus.SUCCESS: - case RestoreStatus.FAILED: - return false; - default: - return true; - } - }) - .isPresent(); - - if (isRunning) { - try { - return Futures.supplyDelayed(() -> getStatusRecursively(backend, backupId, restoreResult), WAIT_INTERVAL, - executor); - } catch (InterruptedException e) { - throw new CompletionException(e); - } - } - return CompletableFuture.completedFuture(merge(restoreStatusResult, restoreResult)); - }, executor); - } - - private Result merge(Result restoreStatusResult, - Result restoreResult) { - BackupRestoreStatusResponse restoreStatusResponse = restoreStatusResult.getResult(); - BackupRestoreResponse restoreResponse = restoreResult.getResult(); - - BackupRestoreResponse merged = null; - int statusCode = HttpStatus.SC_OK; - WeaviateErrorResponse errorResponse = null; - - if (restoreStatusResponse != null) { - merged = new BackupRestoreResponse(); - - merged.setId(restoreStatusResponse.getId()); - merged.setBackend(restoreStatusResponse.getBackend()); - merged.setPath(restoreStatusResponse.getPath()); - merged.setStatus(restoreStatusResponse.getStatus()); - merged.setError(restoreStatusResponse.getError()); - merged.setClassNames(restoreResponse.getClassNames()); - } - if (restoreStatusResult.hasErrors()) { - WeaviateError error = restoreStatusResult.getError(); - statusCode = error.getStatusCode(); - List messages = error.getMessages(); - - errorResponse = WeaviateErrorResponse.builder() - .code(statusCode) - .error(messages) - .build(); - } - - return new Result<>(statusCode, merged, errorResponse); - } - - @Getter - @Builder - private static class BackupRestore { - @SerializedName("config") - BackupRestoreConfig config; - @SerializedName("include") - String[] include; - @SerializedName("exclude") - String[] exclude; - @SerializedName("overwriteAlias") - Boolean overwriteAlias; - } - - @Getter - @Builder - public static class BackupRestoreConfig { - @SerializedName("CPUPercentage") - Integer cpuPercentage; - @SerializedName("Bucket") - String bucket; - @SerializedName("Path") - String path; - @SerializedName("usersOptions") - RbacRestoreOption usersRestore; - @SerializedName("rolesOptions") - RbacRestoreOption rolesRestore; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/batch/Batch.java b/src/main/java/io/weaviate/client/v1/async/batch/Batch.java deleted file mode 100644 index 3cfe8ff02..000000000 --- a/src/main/java/io/weaviate/client/v1/async/batch/Batch.java +++ /dev/null @@ -1,213 +0,0 @@ -package io.weaviate.client.v1.async.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.async.batch.api.ObjectsBatchDeleter; -import io.weaviate.client.v1.async.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.async.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.async.data.Data; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.api.ReferencePayloadBuilder; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import io.weaviate.client.v1.batch.util.ReferencesPath; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import java.util.concurrent.Executor; - -public class Batch { - private final CloseableHttpAsyncClient client; - private final Config config; - private final ObjectsPath objectsPath; - private final ReferencesPath referencesPath; - private final BeaconPath beaconPath; - private final Data data; - private final GrpcVersionSupport grpcVersionSupport; - private final AccessTokenProvider tokenProvider; - - public Batch(CloseableHttpAsyncClient client, Config config, DbVersionSupport dbVersionSupport, - GrpcVersionSupport grpcVersionSupport, AccessTokenProvider tokenProvider, Data data) { - this.client = client; - this.config = config; - this.objectsPath = new ObjectsPath(); - this.referencesPath = new ReferencesPath(); - this.beaconPath = new BeaconPath(dbVersionSupport); - this.grpcVersionSupport = grpcVersionSupport; - this.tokenProvider = tokenProvider; - this.data = data; - } - - public ObjectsBatcher objectsBatcher() { - return objectsBatcher(ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), null); - } - - public ObjectsBatcher objectsBatcher(Executor executor) { - return objectsBatcher(ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), executor); - } - - public ObjectsBatcher objectsBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig) { - return objectsBatcher(batchRetriesConfig, null); - } - - public ObjectsBatcher objectsBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, Executor executor) { - return ObjectsBatcher.create(client, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, executor); - } - - public ObjectsBatcher objectsAutoBatcher() { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - ObjectsBatcher.AutoBatchConfig.defaultConfig().build(), - null - ); - } - - public ObjectsBatcher objectsAutoBatcher(Executor executor) { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - ObjectsBatcher.AutoBatchConfig.defaultConfig().build(), - executor - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig) { - return objectsAutoBatcher( - batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig.defaultConfig().build(), - null - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - Executor executor) { - return objectsAutoBatcher( - batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig.defaultConfig().build(), - executor - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.AutoBatchConfig autoBatchConfig) { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig, - null - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig, - executor - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig autoBatchConfig) { - return objectsAutoBatcher( - batchRetriesConfig, - autoBatchConfig, - null - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - return ObjectsBatcher.createAuto(client, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, autoBatchConfig, executor); - } - - public ObjectsBatchDeleter objectsBatchDeleter() { - return new ObjectsBatchDeleter(client, config, tokenProvider, objectsPath); - } - - public ReferencePayloadBuilder referencePayloadBuilder() { - return new ReferencePayloadBuilder(beaconPath); - } - - public ReferencesBatcher referencesBatcher() { - return referencesBatcher(ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), null); - } - - public ReferencesBatcher referencesBatcher(Executor executor) { - return referencesBatcher(ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), executor); - } - - public ReferencesBatcher referencesBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig) { - return referencesBatcher(batchRetriesConfig, null); - } - - public ReferencesBatcher referencesBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - Executor executor) { - return ReferencesBatcher.create(client, config, tokenProvider, referencesPath, batchRetriesConfig, executor); - } - - public ReferencesBatcher referencesAutoBatcher() { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - ReferencesBatcher.AutoBatchConfig.defaultConfig().build(), - null - ); - } - - public ReferencesBatcher referencesAutoBatcher(Executor executor) { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - ReferencesBatcher.AutoBatchConfig.defaultConfig().build(), - executor - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig) { - return referencesAutoBatcher( - batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig.defaultConfig().build(), - null - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - Executor executor) { - return referencesAutoBatcher( - batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig.defaultConfig().build(), - executor - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.AutoBatchConfig autoBatchConfig) { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig, - null - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig, - executor - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig autoBatchConfig) { - return referencesAutoBatcher( - batchRetriesConfig, - autoBatchConfig, - null - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - return ReferencesBatcher.createAuto(client, config, tokenProvider, referencesPath, batchRetriesConfig, autoBatchConfig, executor); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatchDeleter.java b/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatchDeleter.java deleted file mode 100644 index 97b06fc07..000000000 --- a/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatchDeleter.java +++ /dev/null @@ -1,81 +0,0 @@ -package io.weaviate.client.v1.async.batch.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import io.weaviate.client.v1.filters.WhereFilter; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class ObjectsBatchDeleter extends AsyncBaseClient implements AsyncClientResult { - private final ObjectsPath objectsPath; - private String className; - private String consistencyLevel; - private String tenant; - private WhereFilter where; - private String output; - private Boolean dryRun; - - public ObjectsBatchDeleter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - } - - public ObjectsBatchDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsBatchDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectsBatchDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectsBatchDeleter withWhere(WhereFilter where) { - this.where = where; - return this; - } - - public ObjectsBatchDeleter withOutput(String output) { - this.output = output; - return this; - } - - public ObjectsBatchDeleter withDryRun(Boolean dryRun) { - this.dryRun = dryRun; - return this; - } - - @Override - public Future> run() { - return run(null); - } - - @Override - public Future> run(FutureCallback> callback) { - io.weaviate.client.v1.batch.api.ObjectsBatchDeleter.BatchDeleteMatch match = io.weaviate.client.v1.batch.api.ObjectsBatchDeleter.BatchDeleteMatch.builder() - .className(className) - .whereFilter(where) - .build(); - io.weaviate.client.v1.batch.api.ObjectsBatchDeleter.BatchDelete batchDelete = io.weaviate.client.v1.batch.api.ObjectsBatchDeleter.BatchDelete.builder() - .dryRun(dryRun) - .output(output) - .match(match) - .build(); - String path = objectsPath.buildDelete(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .build()); - return sendDeleteRequest(path, batchDelete, BatchDeleteResponse.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatcher.java b/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatcher.java deleted file mode 100644 index bbaf8c4a2..000000000 --- a/src/main/java/io/weaviate/client/v1/async/batch/api/ObjectsBatcher.java +++ /dev/null @@ -1,593 +0,0 @@ -package io.weaviate.client.v1.async.batch.api; - -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; -import java.util.function.Consumer; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.commons.lang3.tuple.Pair; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.grpc.AsyncGrpcClient; -import io.weaviate.client.base.util.Assert; -import io.weaviate.client.base.util.Futures; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.v1.async.data.Data; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.grpc.BatchObjectConverter; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsBatchRequestBody; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -public class ObjectsBatcher extends AsyncBaseClient - implements AsyncClientResult { - - private final Data data; - private final ObjectsPath objectsPath; - private final AccessTokenProvider tokenProvider; - private final GrpcVersionSupport grpcVersionSupport; - - private final ObjectsBatcher.BatchRetriesConfig batchRetriesConfig; - private final ObjectsBatcher.AutoBatchConfig autoBatchConfig; - private final Config config; - private final boolean autoRunEnabled; - private final Executor executor; - private final List>> futures; - - private final List objects; - private String consistencyLevel; - - private ObjectsBatcher(CloseableHttpAsyncClient client, Config config, Data data, ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, ObjectsBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - super(client, config, tokenProvider); - this.config = config; - this.tokenProvider = tokenProvider; - this.data = data; - this.objectsPath = objectsPath; - this.grpcVersionSupport = grpcVersionSupport; - this.batchRetriesConfig = batchRetriesConfig; - this.objects = Collections.synchronizedList(new ArrayList<>()); - this.futures = Collections.synchronizedList(new ArrayList<>()); - this.executor = executor; - - if (autoBatchConfig != null) { - this.autoRunEnabled = true; - this.autoBatchConfig = autoBatchConfig; - } else { - this.autoRunEnabled = false; - this.autoBatchConfig = null; - } - } - - public static ObjectsBatcher create(CloseableHttpAsyncClient client, Config config, Data data, - ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - Executor executor) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - return new ObjectsBatcher(client, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, null, executor); - } - - public static ObjectsBatcher createAuto(CloseableHttpAsyncClient client, Config config, Data data, - ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, ObjectsBatcher.AutoBatchConfig autoBatchConfig, - Executor executor) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - Assert.requiredNotNull(autoBatchConfig, "autoBatchConfig"); - return new ObjectsBatcher(client, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, autoBatchConfig, executor); - } - - public ObjectsBatcher withObject(WeaviateObject object) { - return withObjects(object); - } - - public ObjectsBatcher withObjects(WeaviateObject... objects) { - addMissingIds(objects); - this.objects.addAll(Arrays.asList(objects)); - autoRun(); - return this; - } - - public ObjectsBatcher withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - private void addMissingIds(WeaviateObject[] objects) { - Arrays.stream(objects) - .filter(o -> o.getId() == null) - .forEach(o -> o.setId(UUID.randomUUID().toString())); - } - - private List extractBatch(int batchSize) { - List batch = new ArrayList<>(batchSize); - List sublist = objects.subList(0, batchSize); - - batch.addAll(sublist); - sublist.clear(); - - return batch; - } - - private void autoRun() { - if (!autoRunEnabled) { - return; - } - - while (objects.size() >= autoBatchConfig.batchSize) { - List batch = extractBatch(autoBatchConfig.batchSize); - runBatch(batch); - } - } - - @Override - public Future> run(FutureCallback> callback) { - CompletableFuture> future = runAll(); - if (callback != null) { - future = future.whenComplete((result, throwable) -> { - if (throwable != null) { - callback.failed((Exception) throwable); - } else { - callback.completed(result); - } - }); - } - return future; - } - - private CompletableFuture> runAll() { - if (!autoRunEnabled) { - if (objects.isEmpty()) { - return CompletableFuture.completedFuture(new Result<>(0, new ObjectGetResponse[0], null)); - } - - List batch = extractBatch(objects.size()); - return runBatchRecursively(batch, 0, 0, null); - } - - if (!objects.isEmpty()) { - List batch = extractBatch(objects.size()); - runBatch(batch); - } - if (futures.isEmpty()) { - return CompletableFuture.completedFuture(new Result<>(0, new ObjectGetResponse[0], null)); - } - - CompletableFuture[] futuresAsArray = futures.toArray(new CompletableFuture[0]); - return CompletableFuture.allOf(futuresAsArray).thenApply(v -> { - List allResponses = new ArrayList<>(); - List allMessages = new ArrayList<>(); - int[] lastErrStatusCode = new int[] { HttpStatus.SC_OK }; - - futures.stream().map(resultCompletableFuture -> { - try { - return resultCompletableFuture.get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }).forEach(result -> { - Optional.ofNullable(result) - .map(Result::getResult) - .map(Arrays::asList) - .ifPresent(allResponses::addAll); - Optional.ofNullable(result) - .filter(Result::hasErrors) - .map(Result::getError) - .map(WeaviateError::getMessages) - .ifPresent(allMessages::addAll); - Optional.ofNullable(result) - .filter(Result::hasErrors) - .map(Result::getError) - .map(WeaviateError::getStatusCode) - .ifPresent(sc -> lastErrStatusCode[0] = sc); - }); - - WeaviateErrorResponse errorResponse = allMessages.isEmpty() - ? null - : WeaviateErrorResponse.builder().error(allMessages).code(lastErrStatusCode[0]).build(); - return new Result<>(lastErrStatusCode[0], allResponses.toArray(new ObjectGetResponse[0]), errorResponse); - }); - } - - private void runBatch(List batch) { - CompletableFuture> future = runBatchRecursively(batch, 0, 0, null); - if (autoBatchConfig.callback != null) { - future = future.whenComplete((result, t) -> autoBatchConfig.callback.accept(result)); - } - futures.add(future); - } - - private CompletableFuture> runBatchRecursively(List batch, - int connectionErrorCount, int timeoutErrorCount, - List combinedSingleResponses) { - return Futures.handleAsync(internalRun(batch), (result, throwable) -> { - List tempCombinedSingleResponses = combinedSingleResponses; - List tempBatch = batch; - - if (throwable != null) { - boolean executeAgain = false; - int tempConnCount = connectionErrorCount; - int tempTimeCount = timeoutErrorCount; - int delay = 0; - - if (throwable instanceof ConnectException) { - if (tempConnCount++ < batchRetriesConfig.maxConnectionRetries) { - executeAgain = true; - delay = tempConnCount * batchRetriesConfig.retriesIntervalMs; - } - } else if (throwable instanceof SocketTimeoutException) { - Pair, List> pair = fetchCreatedAndBuildBatchToReRun(tempBatch); - tempCombinedSingleResponses = combineSingleResponses(tempCombinedSingleResponses, pair.getLeft()); - tempBatch = pair.getRight(); - - if (ObjectUtils.isNotEmpty(tempBatch) && tempTimeCount++ < batchRetriesConfig.maxTimeoutRetries) { - executeAgain = true; - delay = tempTimeCount * batchRetriesConfig.retriesIntervalMs; - } - } - if (executeAgain) { - try { - List finalCombinedSingleResponses = tempCombinedSingleResponses; - List finalBatch = tempBatch; - int connCount = tempConnCount; - int timeCount = tempTimeCount; - return Futures.supplyDelayed( - () -> runBatchRecursively(finalBatch, connCount, timeCount, finalCombinedSingleResponses), delay, - executor); - } catch (InterruptedException e) { - throw new CompletionException(e); - } - } - } else if (!result.hasErrors()) { - tempBatch = null; - } - - return CompletableFuture.completedFuture(createFinalResultFromLastResultAndCombinedSingleResponses(result, - throwable, tempCombinedSingleResponses, tempBatch)); - }, executor); - } - - private CompletableFuture> internalRun(List batch) { - return config.useGRPC() ? internalGrpcRun(batch) : internalHttpRun(batch); - } - - private CompletableFuture> internalGrpcRun(List batch) { - BatchObjectConverter batchObjectConverter = new BatchObjectConverter(grpcVersionSupport); - List batchObjects = batch.stream() - .map(batchObjectConverter::toBatchObject) - .collect(Collectors.toList()); - - WeaviateProtoBatch.BatchObjectsRequest.Builder batchObjectsRequestBuilder = WeaviateProtoBatch.BatchObjectsRequest - .newBuilder(); - batchObjectsRequestBuilder.addAllObjects(batchObjects); - Optional.ofNullable(consistencyLevel) - .map(cl -> { - switch (cl) { - case ConsistencyLevel.ALL: - return WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ALL; - case ConsistencyLevel.QUORUM: - return WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_QUORUM; - default: - return WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE; - } - }).ifPresent(batchObjectsRequestBuilder::setConsistencyLevel); - WeaviateProtoBatch.BatchObjectsRequest batchObjectsRequest = batchObjectsRequestBuilder.build(); - - // TODO convert ListenableFuture into CompletableFuture? - return Futures.supplyAsync(() -> { - AsyncGrpcClient grpcClient = AsyncGrpcClient.create(config, tokenProvider); - try { - return grpcClient.batchObjects(batchObjectsRequest).get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } finally { - grpcClient.shutdown(); - } - }, executor) - .thenApply(batchObjectsReply -> { - return io.weaviate.client.v1.batch.api.ObjectsBatcher.resultFromBatchObjectsReply(batchObjectsReply, batch); - }); - } - - private CompletableFuture> internalHttpRun(List batch) { - CompletableFuture> future = new CompletableFuture<>(); - ObjectsBatchRequestBody payload = ObjectsBatchRequestBody.builder() - .objects(batch.toArray(new WeaviateObject[0])) - .fields(new String[] { "ALL" }) - .build(); - String path = objectsPath.buildCreate(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - sendPostRequest(path, payload, ObjectGetResponse[].class, new FutureCallback>() { - @Override - public void completed(Result batchResult) { - future.complete(batchResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - return future; - } - - private Pair, List> fetchCreatedAndBuildBatchToReRun( - List batch) { - List rerunBatch = new ArrayList<>(batch.size()); - List createdResponses = new ArrayList<>(batch.size()); - List>>> futures = new ArrayList<>(batch.size()); - - for (WeaviateObject batchObject : batch) { - futures.add(fetchExistingObject(batchObject)); - } - CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join(); - - try { - for (int i = 0; i < batch.size(); i++) { - CompletableFuture>> future = futures.get(i); - WeaviateObject batchObject = batch.get(i); - - if (future.isCompletedExceptionally()) { - rerunBatch.add(batchObject); - continue; - } - - Result> existingResult = future.get(); - if (existingResult.hasErrors() || ObjectUtils.isEmpty(existingResult.getResult())) { - rerunBatch.add(batchObject); - continue; - } - - WeaviateObject existingObject = existingResult.getResult().get(0); - if (isDifferentObject(batchObject, existingObject)) { - rerunBatch.add(batchObject); - continue; - } - - createdResponses.add(createResponseFromExistingObject(existingObject)); - } - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - - return Pair.of(createdResponses, rerunBatch); - } - - private CompletableFuture>> fetchExistingObject(WeaviateObject batchObject) { - CompletableFuture>> future = new CompletableFuture<>(); - data.objectsGetter() - .withID(batchObject.getId()) - .withClassName(batchObject.getClassName()) - .withVector() - .run(new FutureCallback>>() { - @Override - public void completed(Result> objectsResult) { - future.complete(objectsResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - - return future; - } - - private boolean isDifferentObject(WeaviateObject batchObject, WeaviateObject existingObject) { - if ((existingObject.getVector() != null || batchObject.getVector() != null) - && !Arrays.equals(existingObject.getVector(), batchObject.getVector())) { - return true; - } - - Map existingProperties = existingObject.getProperties(); - Map batchProperties = batchObject.getProperties(); - - if ((existingProperties != null && batchProperties == null) - || (existingProperties == null && batchProperties != null)) { - return true; - } - - if (existingProperties != null && !existingProperties.equals(batchProperties)) { - // TODO improve as lists will always be != - return true; - } - - return false; - } - - private ObjectGetResponse createResponseFromExistingObject(WeaviateObject existingObject) { - ObjectsGetResponseAO2Result result = new ObjectsGetResponseAO2Result(); - result.setStatus(ObjectGetResponseStatus.SUCCESS); - - ObjectGetResponse response = new ObjectGetResponse(); - response.setId(existingObject.getId()); - response.setClassName(existingObject.getClassName()); - response.setProperties(existingObject.getProperties()); - response.setAdditional(existingObject.getAdditional()); - response.setCreationTimeUnix(existingObject.getCreationTimeUnix()); - response.setLastUpdateTimeUnix(existingObject.getLastUpdateTimeUnix()); - response.setVector(existingObject.getVector()); - response.setVectors(existingObject.getVectors()); - response.setMultiVectors(existingObject.getMultiVectors()); - response.setVectorWeights(existingObject.getVectorWeights()); - response.setResult(result); - - return response; - } - - private List combineSingleResponses(List combinedSingleResponses, - List createdResponses) { - if (ObjectUtils.isNotEmpty(createdResponses)) { - combinedSingleResponses = ObjectUtils.isEmpty(combinedSingleResponses) - ? createdResponses - : Stream.of(combinedSingleResponses, createdResponses) - .flatMap(Collection::stream) - .collect(Collectors.toList()); - } - - return combinedSingleResponses; - } - - private Result createFinalResultFromLastResultAndCombinedSingleResponses( - Result lastResult, - Throwable throwable, - List combinedSingleResponses, - List failedBatch) { - int statusCode = 0; - if (throwable != null && lastResult == null) { - lastResult = new Result<>(statusCode, null, WeaviateErrorResponse.builder() - .error(Collections.singletonList(WeaviateErrorMessage.builder() - .message(throwable.getMessage()) - .throwable(throwable) - .build())) - .code(statusCode) - .build()); - } - - if (ObjectUtils.isEmpty(failedBatch) && ObjectUtils.isEmpty(combinedSingleResponses)) { - return lastResult; - } - - ObjectGetResponse[] allResponses = null; - if (ObjectUtils.isNotEmpty(lastResult.getResult())) { - allResponses = lastResult.getResult(); - } - if (ObjectUtils.isNotEmpty(combinedSingleResponses)) { - allResponses = ArrayUtils.addAll(allResponses, combinedSingleResponses.toArray(new ObjectGetResponse[0])); - } - - if (ObjectUtils.isEmpty(failedBatch)) { - return new Result<>(statusCode, allResponses, null); - } - - String failedIds = failedBatch.stream().map(WeaviateObject::getId).collect(Collectors.joining(", ")); - WeaviateErrorMessage failedIdsMessage = WeaviateErrorMessage.builder().message("Failed ids: " + failedIds).build(); - List messages; - - if (lastResult.hasErrors()) { - statusCode = lastResult.getError().getStatusCode(); - List prevMessages = lastResult.getError().getMessages(); - messages = new ArrayList<>(prevMessages.size() + 1); - messages.addAll(prevMessages); - messages.add(failedIdsMessage); - } else { - messages = Collections.singletonList(failedIdsMessage); - } - - return new Result<>(statusCode, allResponses, WeaviateErrorResponse.builder() - .error(messages) - .code(statusCode) - .build()); - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class BatchRetriesConfig { - - public static final int MAX_TIMEOUT_RETRIES = 3; - public static final int MAX_CONNECTION_RETRIES = 3; - public static final int RETRIES_INTERVAL = 2000; - - int maxTimeoutRetries; - int maxConnectionRetries; - int retriesIntervalMs; - - private BatchRetriesConfig(int maxTimeoutRetries, int maxConnectionRetries, int retriesIntervalMs) { - Assert.requireGreaterEqual(maxTimeoutRetries, 0, "maxTimeoutRetries"); - Assert.requireGreaterEqual(maxConnectionRetries, 0, "maxConnectionRetries"); - Assert.requireGreater(retriesIntervalMs, 0, "retriesIntervalMs"); - - this.maxTimeoutRetries = maxTimeoutRetries; - this.maxConnectionRetries = maxConnectionRetries; - this.retriesIntervalMs = retriesIntervalMs; - } - - public static ObjectsBatcher.BatchRetriesConfig.BatchRetriesConfigBuilder defaultConfig() { - return ObjectsBatcher.BatchRetriesConfig.builder() - .maxTimeoutRetries(MAX_TIMEOUT_RETRIES) - .maxConnectionRetries(MAX_CONNECTION_RETRIES) - .retriesIntervalMs(RETRIES_INTERVAL); - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class AutoBatchConfig { - - public static final int BATCH_SIZE = 100; - - int batchSize; - Consumer> callback; - - private AutoBatchConfig(int batchSize, Consumer> callback) { - Assert.requireGreaterEqual(batchSize, 1, "batchSize"); - - this.batchSize = batchSize; - this.callback = callback; - } - - public static ObjectsBatcher.AutoBatchConfig.AutoBatchConfigBuilder defaultConfig() { - return ObjectsBatcher.AutoBatchConfig.builder() - .batchSize(BATCH_SIZE) - .callback(null); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/batch/api/ReferencesBatcher.java b/src/main/java/io/weaviate/client/v1/async/batch/api/ReferencesBatcher.java deleted file mode 100644 index 17744eddd..000000000 --- a/src/main/java/io/weaviate/client/v1/async/batch/api/ReferencesBatcher.java +++ /dev/null @@ -1,347 +0,0 @@ -package io.weaviate.client.v1.async.batch.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.util.Assert; -import io.weaviate.client.base.util.Futures; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.util.ReferencesPath; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; -import java.util.function.Consumer; -import java.util.stream.Collectors; - -public class ReferencesBatcher extends AsyncBaseClient - implements AsyncClientResult { - - private final ReferencesPath referencesPath; - - private final BatchRetriesConfig batchRetriesConfig; - private final AutoBatchConfig autoBatchConfig; - private final boolean autoRunEnabled; - private final Executor executor; - private final List>> futures; - - private final List references; - private String consistencyLevel; - - - private ReferencesBatcher(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig, - Executor executor) { - super(client, config, tokenProvider); - this.referencesPath = referencesPath; - this.futures = Collections.synchronizedList(new ArrayList<>()); - this.references = Collections.synchronizedList(new ArrayList<>()); - this.batchRetriesConfig = batchRetriesConfig; - this.executor = executor; - - if (autoBatchConfig != null) { - this.autoRunEnabled = true; - this.autoBatchConfig = autoBatchConfig; - } else { - this.autoRunEnabled = false; - this.autoBatchConfig = null; - } - } - - public static ReferencesBatcher create(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig, Executor executor) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - return new ReferencesBatcher(client, config, tokenProvider, referencesPath, batchRetriesConfig, null, executor); - } - - public static ReferencesBatcher createAuto(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig, - Executor executor) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - Assert.requiredNotNull(autoBatchConfig, "autoBatchConfig"); - return new ReferencesBatcher(client, config, tokenProvider, referencesPath, batchRetriesConfig, autoBatchConfig, executor); - } - - - public ReferencesBatcher withReference(BatchReference reference) { - return withReferences(reference); - } - - public ReferencesBatcher withReferences(BatchReference... references) { - this.references.addAll(Arrays.asList(references)); - autoRun(); - return this; - } - - public ReferencesBatcher withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - CompletableFuture> future = runAll(); - if (callback != null) { - future = future.whenComplete((result, throwable) -> { - if (throwable != null) { - callback.failed((Exception) throwable); - } else { - callback.completed(result); - } - }); - } - return future; - } - - private CompletableFuture> runAll() { - if (!autoRunEnabled) { - if (references.isEmpty()) { - return CompletableFuture.completedFuture(new Result<>(0, new BatchReferenceResponse[0], null)); - } - - List batch = extractBatch(references.size()); - return runBatchRecursively(batch, 0, 0); - } - - if (!references.isEmpty()) { - List batch = extractBatch(references.size()); - runBatch(batch); - } - if (futures.isEmpty()) { - return CompletableFuture.completedFuture(new Result<>(0, new BatchReferenceResponse[0], null)); - } - - CompletableFuture[] futuresAsArray = futures.toArray(new CompletableFuture[0]); - return CompletableFuture.allOf(futuresAsArray).thenApply(v -> { - List allResponses = new ArrayList<>(); - List allMessages = new ArrayList<>(); - int[] lastErrStatusCode = new int[]{HttpStatus.SC_OK}; - - futures.stream().map(resultCompletableFuture -> { - try { - return resultCompletableFuture.get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }).forEach(result -> { - Optional.ofNullable(result) - .map(Result::getResult) - .map(Arrays::asList) - .ifPresent(allResponses::addAll); - Optional.ofNullable(result) - .filter(Result::hasErrors) - .map(Result::getError) - .map(WeaviateError::getMessages) - .ifPresent(allMessages::addAll); - Optional.ofNullable(result) - .filter(Result::hasErrors) - .map(Result::getError) - .map(WeaviateError::getStatusCode) - .ifPresent(sc -> lastErrStatusCode[0] = sc); - }); - - WeaviateErrorResponse errorResponse = allMessages.isEmpty() - ? null - : WeaviateErrorResponse.builder().error(allMessages).code(lastErrStatusCode[0]).build(); - return new Result<>(lastErrStatusCode[0], allResponses.toArray(new BatchReferenceResponse[0]), errorResponse); - }); - } - - private List extractBatch(int batchSize) { - List batch = new ArrayList<>(batchSize); - List sublist = references.subList(0, batchSize); - - batch.addAll(sublist); - sublist.clear(); - - return batch; - } - - private void autoRun() { - if (!autoRunEnabled) { - return; - } - - while (references.size() >= autoBatchConfig.batchSize) { - List batch = extractBatch(autoBatchConfig.batchSize); - runBatch(batch); - } - } - - private void runBatch(List batch) { - CompletableFuture> future = runBatchRecursively(batch, 0, 0); - if (autoBatchConfig.callback != null) { - future = future.whenComplete((result, e) -> autoBatchConfig.callback.accept(result)); - } - futures.add(future); - } - - private CompletableFuture> runBatchRecursively(List batch, - int connectionErrorCount, int timeoutErrorCount) { - return Futures.handleAsync(internalRun(batch), (result, throwable) -> { - if (throwable != null) { - boolean executeAgain = false; - int tempConnCount = connectionErrorCount; - int tempTimeCount = timeoutErrorCount; - int delay = 0; - - if (throwable instanceof ConnectException) { - if (tempConnCount++ < batchRetriesConfig.maxConnectionRetries) { - executeAgain = true; - delay = tempConnCount * batchRetriesConfig.retriesIntervalMs; - } - } else if (throwable instanceof SocketTimeoutException) { - if (tempTimeCount++ < batchRetriesConfig.maxTimeoutRetries) { - executeAgain = true; - delay = tempTimeCount * batchRetriesConfig.retriesIntervalMs; - } - } - if (executeAgain) { - int finalConnCount = tempConnCount; - int finalTimeCount = tempTimeCount; - try { - return Futures.supplyDelayed(() -> runBatchRecursively(batch, finalConnCount, finalTimeCount), delay, executor); - } catch (InterruptedException e) { - throw new CompletionException(e); - } - } - } - - return CompletableFuture.completedFuture(createFinalResultFromLastResult(result, throwable, batch)); - }, executor); - } - - private CompletableFuture> internalRun(List batch) { - CompletableFuture> future = new CompletableFuture<>(); - BatchReference[] payload = batch.toArray(new BatchReference[0]); - String path = referencesPath.buildCreate(ReferencesPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - - sendPostRequest(path, payload, BatchReferenceResponse[].class, new FutureCallback>() { - @Override - public void completed(Result batchResult) { - future.complete(batchResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - return future; - } - - private Result createFinalResultFromLastResult(Result lastResult, - Throwable throwable, - List batch) { - if (lastResult != null) { - return lastResult; - } - - int statusCode = 0; - String failedRefs = batch.stream() - .map(ref -> ref.getFrom() + " => " + ref.getTo()) - .collect(Collectors.joining(", ")); - WeaviateErrorMessage failedRefsMessage = WeaviateErrorMessage.builder() - .message("Failed refs: " + failedRefs) - .build(); - WeaviateErrorMessage throwableMessage = WeaviateErrorMessage.builder() - .message(throwable.getMessage()) - .throwable(throwable) - .build(); - return new Result<>(statusCode, null, WeaviateErrorResponse.builder() - .error(Arrays.asList(throwableMessage, failedRefsMessage)) - .code(statusCode) - .build() - ); - } - - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class BatchRetriesConfig { - - public static final int MAX_TIMEOUT_RETRIES = 3; - public static final int MAX_CONNECTION_RETRIES = 3; - public static final int RETRIES_INTERVAL = 2000; - - int maxTimeoutRetries; - int maxConnectionRetries; - int retriesIntervalMs; - - private BatchRetriesConfig(int maxTimeoutRetries, int maxConnectionRetries, int retriesIntervalMs) { - Assert.requireGreaterEqual(maxTimeoutRetries, 0, "maxTimeoutRetries"); - Assert.requireGreaterEqual(maxConnectionRetries, 0, "maxConnectionRetries"); - Assert.requireGreater(retriesIntervalMs, 0, "retriesIntervalMs"); - - this.maxTimeoutRetries = maxTimeoutRetries; - this.maxConnectionRetries = maxConnectionRetries; - this.retriesIntervalMs = retriesIntervalMs; - } - - public static ReferencesBatcher.BatchRetriesConfig.BatchRetriesConfigBuilder defaultConfig() { - return BatchRetriesConfig.builder() - .maxTimeoutRetries(MAX_TIMEOUT_RETRIES) - .maxConnectionRetries(MAX_CONNECTION_RETRIES) - .retriesIntervalMs(RETRIES_INTERVAL); - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class AutoBatchConfig { - - public static final int BATCH_SIZE = 100; - - int batchSize; - Consumer> callback; - - private AutoBatchConfig(int batchSize, Consumer> callback) { - Assert.requireGreaterEqual(batchSize, 1, "batchSize"); - - this.batchSize = batchSize; - this.callback = callback; - } - - public static ReferencesBatcher.AutoBatchConfig.AutoBatchConfigBuilder defaultConfig() { - return AutoBatchConfig.builder() - .batchSize(BATCH_SIZE) - .callback(null); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/classifications/Classifications.java b/src/main/java/io/weaviate/client/v1/async/classifications/Classifications.java deleted file mode 100644 index a4e8922c2..000000000 --- a/src/main/java/io/weaviate/client/v1/async/classifications/Classifications.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.classifications; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.classifications.api.Getter; -import io.weaviate.client.v1.async.classifications.api.Scheduler; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import java.util.concurrent.Executor; - -@RequiredArgsConstructor -public class Classifications { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - - public Scheduler scheduler() { - return scheduler(null); - } - - public Scheduler scheduler(Executor executor) { - return new Scheduler(client, config, tokenProvider, getter(), executor); - } - - public Getter getter() { - return new Getter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/classifications/api/Getter.java b/src/main/java/io/weaviate/client/v1/async/classifications/api/Getter.java deleted file mode 100644 index d895f6205..000000000 --- a/src/main/java/io/weaviate/client/v1/async/classifications/api/Getter.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.weaviate.client.v1.async.classifications.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.classifications.model.Classification; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; - -public class Getter extends AsyncBaseClient - implements AsyncClientResult { - - private String id; - - - public Getter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - - public Getter withID(String id) { - this.id = id; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isBlank(id)) { - return CompletableFuture.completedFuture(null); - } - String path = String.format("/classifications/%s", UrlEncoder.encodePathParam(id)); - return sendGetRequest(path, Classification.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/classifications/api/Scheduler.java b/src/main/java/io/weaviate/client/v1/async/classifications/api/Scheduler.java deleted file mode 100644 index e156b3d03..000000000 --- a/src/main/java/io/weaviate/client/v1/async/classifications/api/Scheduler.java +++ /dev/null @@ -1,204 +0,0 @@ -package io.weaviate.client.v1.async.classifications.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.Futures; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.classifications.model.Classification; -import io.weaviate.client.v1.classifications.model.ClassificationFilters; -import io.weaviate.client.v1.filters.WhereFilter; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.Optional; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.Executor; -import java.util.concurrent.Future; - -public class Scheduler extends AsyncBaseClient - implements AsyncClientResult { - - private static final long WAIT_INTERVAL = 2000; - - private String classificationType; - private String className; - private String[] classifyProperties; - private String[] basedOnProperties; - private WhereFilter sourceWhereFilter; - private WhereFilter trainingSetWhereFilter; - private WhereFilter targetWhereFilter; - private boolean waitForCompletion; - private Object settings; - - private final Getter getter; - private final Executor executor; - - - public Scheduler(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, Getter getter, Executor executor) { - super(client, config, tokenProvider); - this.getter = getter; - this.executor = executor; - } - - - public Scheduler withType(String classificationType) { - this.classificationType = classificationType; - return this; - } - - public Scheduler withClassName(String className) { - this.className = className; - return this; - } - - public Scheduler withClassifyProperties(String[] classifyProperties) { - this.classifyProperties = classifyProperties; - return this; - } - - public Scheduler withBasedOnProperties(String[] basedOnProperties) { - this.basedOnProperties = basedOnProperties; - return this; - } - - public Scheduler withSourceWhereFilter(WhereFilter whereFilter) { - this.sourceWhereFilter = whereFilter; - return this; - } - - public Scheduler withTrainingSetWhereFilter(WhereFilter whereFilter) { - this.trainingSetWhereFilter = whereFilter; - return this; - } - - public Scheduler withTargetWhereFilter(WhereFilter whereFilter) { - this.targetWhereFilter = whereFilter; - return this; - } - - public Scheduler withSettings(Object settings) { - this.settings = settings; - return this; - } - - public Scheduler withWaitForCompletion() { - this.waitForCompletion = true; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - if (waitForCompletion) { - return scheduleAndWaitForCompletion(callback); - } - return schedule(callback); - } - - private Future> schedule(FutureCallback> callback) { - Classification config = Classification.builder() - .basedOnProperties(basedOnProperties) - .className(className) - .classifyProperties(classifyProperties) - .type(classificationType) - .settings(settings) - .filters(getClassificationFilters(sourceWhereFilter, targetWhereFilter, trainingSetWhereFilter)) - .build(); - return sendPostRequest("/classifications", config, Classification.class, callback); - } - - private Future> scheduleAndWaitForCompletion(FutureCallback> callback) { - CompletableFuture> future = new CompletableFuture<>(); - FutureCallback> internalCallback = new FutureCallback>() { - @Override - public void completed(Result classificationResult) { - future.complete(classificationResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - future.cancel(true); - if (callback != null) { - callback.cancelled(); // TODO:AL propagate cancel() call from future to completable future - } - } - }; - - schedule(internalCallback); - - return future.thenCompose(classificationResult -> { - if (classificationResult.hasErrors()) { - return CompletableFuture.completedFuture(classificationResult); - } - return getByIdRecursively(classificationResult.getResult().getId()); - }) - .whenComplete((classificationResult, throwable) -> { - if (callback != null) { - if (throwable != null) { - callback.failed((Exception) throwable); - } else { - callback.completed(classificationResult); - } - } - }); - } - - private CompletableFuture> getById(String id) { - CompletableFuture> future = new CompletableFuture<>(); - getter.withID(id).run(new FutureCallback>() { - @Override - public void completed(Result classificationResult) { - future.complete(classificationResult); - } - - @Override - public void failed(Exception e) { - future.completeExceptionally(e); - } - - @Override - public void cancelled() { - } - }); - return future; - } - - private CompletableFuture> getByIdRecursively(String id) { - return Futures.thenComposeAsync(getById(id), classificationResult -> { - boolean isRunning = Optional.ofNullable(classificationResult) - .map(Result::getResult) - .map(Classification::getStatus) - .filter(status -> status.equals("running")) - .isPresent(); - - if (isRunning) { - try { - return Futures.supplyDelayed(() -> getByIdRecursively(id), WAIT_INTERVAL, executor); - } catch (InterruptedException e) { - throw new CompletionException(e); - } - } - return CompletableFuture.completedFuture(classificationResult); - }, executor); - } - - private ClassificationFilters getClassificationFilters(WhereFilter sourceWhere, WhereFilter targetWhere, WhereFilter trainingSetWhere) { - if (ObjectUtils.anyNotNull(sourceWhere, targetWhere, trainingSetWhere)) { - return ClassificationFilters.builder() - .sourceWhere(sourceWhere) - .targetWhere(targetWhere) - .trainingSetWhere(trainingSetWhere) - .build(); - } - return null; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/Cluster.java b/src/main/java/io/weaviate/client/v1/async/cluster/Cluster.java deleted file mode 100644 index f6271489d..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/Cluster.java +++ /dev/null @@ -1,35 +0,0 @@ -package io.weaviate.client.v1.async.cluster; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.cluster.api.NodesStatusGetter; -import io.weaviate.client.v1.async.cluster.api.Replicator; -import io.weaviate.client.v1.async.cluster.api.ShardingStateQuerier; -import io.weaviate.client.v1.async.cluster.api.replication.Replication; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Cluster { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public Replication replication() { - return new Replication(client, config, tokenProvider); - } - - public NodesStatusGetter nodesStatusGetter() { - return new NodesStatusGetter(client, config, tokenProvider); - } - - public Replicator replicator() { - return new Replicator(client, config, tokenProvider); - } - - public ShardingStateQuerier shardingStateQuerier() { - return new ShardingStateQuerier(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/NodesStatusGetter.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/NodesStatusGetter.java deleted file mode 100644 index 40b136ba5..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/NodesStatusGetter.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public class NodesStatusGetter extends AsyncBaseClient - implements AsyncClientResult { - - private String className; - private String output; - - - public NodesStatusGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - - public NodesStatusGetter withClassName(String className) { - this.className = className; - return this; - } - - public NodesStatusGetter withOutput(String output) { - this.output = output; - return this; - } - - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest(path(), NodesStatusResponse.class, callback); - } - - private String path() { - String path = "/nodes"; - if (StringUtils.isNotBlank(className)) { - path = String.format("%s/%s", path, UrlEncoder.encodePathParam(className)); - } - if (StringUtils.isNotBlank(output)) { - path = String.format("%s?%s", path, UrlEncoder.encodeQueryParam("output", output)); - } - return path; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/Replicator.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/Replicator.java deleted file mode 100644 index df3542ae8..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/Replicator.java +++ /dev/null @@ -1,79 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.model.ReplicationType; -import lombok.Getter; - -public class Replicator extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String shard; - private String sourceNode; - private String targetNode; - private ReplicationType replicationType; - - public Replicator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public Replicator withClassName(String className) { - this.className = className; - return this; - } - - public Replicator withShard(String shard) { - this.shard = shard; - return this; - } - - public Replicator withSourceNode(String sourceNode) { - this.sourceNode = sourceNode; - return this; - } - - public Replicator withTargetNode(String targetNode) { - this.targetNode = targetNode; - return this; - } - - public Replicator withReplicationType(ReplicationType replicationType) { - this.replicationType = replicationType; - return this; - } - - class RequestBody { - @SerializedName("collection") - String className = Replicator.this.className; - @SerializedName("shard") - String shard = Replicator.this.shard; - @SerializedName("sourceNode") - String sourceNode = Replicator.this.sourceNode; - @SerializedName("targetNode") - String targetNode = Replicator.this.targetNode; - @SerializedName("type") - ReplicationType replicationType = Replicator.this.replicationType; - } - - @Getter - static class ResponseBody { - @SerializedName("id") - String replicationId; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/replication/replicate", new RequestBody(), - callback, Result.mapParser(ResponseBody.class, ResponseBody::getReplicationId)); - - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/ShardingStateQuerier.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/ShardingStateQuerier.java deleted file mode 100644 index dbf6beaed..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/ShardingStateQuerier.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.model.ShardingState; -import lombok.Getter; - -public class ShardingStateQuerier extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String shard; - - public ShardingStateQuerier(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ShardingStateQuerier withClassName(String className) { - this.className = className; - return this; - } - - public ShardingStateQuerier withShard(String shard) { - this.shard = shard; - return this; - } - - @Getter - static class ResponseBody { - @SerializedName("shardingState") - ShardingState state; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = "/replication/sharding-state?" + UrlEncoder.encodeQueryParam("collection", className); - if (shard != null) { - path += "&" + UrlEncoder.encodeQueryParam("shard", shard); - } - return sendGetRequest(path, callback, Result.mapParser(ResponseBody.class, ResponseBody::getState)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/Replication.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/Replication.java deleted file mode 100644 index 272a71ae0..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/Replication.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationAllDeleter; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationAllGetter; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationCanceler; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationDeleter; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationGetter; -import io.weaviate.client.v1.async.cluster.api.replication.api.ReplicationQuerier; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Replication { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public ReplicationGetter getter() { - return new ReplicationGetter(client, config, tokenProvider); - } - - public ReplicationAllGetter allGetter() { - return new ReplicationAllGetter(client, config, tokenProvider); - } - - public ReplicationQuerier querier() { - return new ReplicationQuerier(client, config, tokenProvider); - } - - public ReplicationCanceler canceler() { - return new ReplicationCanceler(client, config, tokenProvider); - } - - public ReplicationDeleter deleter() { - return new ReplicationDeleter(client, config, tokenProvider); - } - - public ReplicationAllDeleter allDeleter() { - return new ReplicationAllDeleter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllDeleter.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllDeleter.java deleted file mode 100644 index 053b7a69e..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllDeleter.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class ReplicationAllDeleter extends AsyncBaseClient implements AsyncClientResult { - - public ReplicationAllDeleter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendDeleteRequest("/replication/replicate", null, callback, Result.voidToBooleanParser()); - - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllGetter.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllGetter.java deleted file mode 100644 index 52f043ef2..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationAllGetter.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationAllGetter extends AsyncBaseClient> - implements AsyncClientResult> { - - public ReplicationAllGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest("/replication/replicate/list?includeHistory=true", callback, - Result.toListParser(ReplicateOperation[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationCanceler.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationCanceler.java deleted file mode 100644 index 2ff83e915..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationCanceler.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class ReplicationCanceler extends AsyncBaseClient implements AsyncClientResult { - private String uuid; - - public ReplicationCanceler(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ReplicationCanceler withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/replication/replicate/" + uuid + "/cancel", null, - callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationDeleter.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationDeleter.java deleted file mode 100644 index 415a9c0a0..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationDeleter.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class ReplicationDeleter extends AsyncBaseClient implements AsyncClientResult { - private String uuid; - - public ReplicationDeleter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ReplicationDeleter withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendDeleteRequest("/replication/replicate/" + uuid, null, - callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationGetter.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationGetter.java deleted file mode 100644 index b97ee0048..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationGetter.java +++ /dev/null @@ -1,43 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationGetter extends AsyncBaseClient - implements AsyncClientResult { - private String uuid; - private Boolean includeHistory; - - public ReplicationGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ReplicationGetter withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - public ReplicationGetter withIncludeHistory(boolean includeHistory) { - this.includeHistory = includeHistory; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = "/replication/replicate/" + uuid; - if (includeHistory != null) { - path += "?" + UrlEncoder.encodeQueryParam("includeHistory", includeHistory.toString()); - } - return sendGetRequest(path, ReplicateOperation.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationQuerier.java b/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationQuerier.java deleted file mode 100644 index 0e931bf12..000000000 --- a/src/main/java/io/weaviate/client/v1/async/cluster/api/replication/api/ReplicationQuerier.java +++ /dev/null @@ -1,63 +0,0 @@ -package io.weaviate.client.v1.async.cluster.api.replication.api; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationQuerier extends AsyncBaseClient> - implements AsyncClientResult> { - private Map queryParams = new HashMap<>(); - - public ReplicationQuerier(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ReplicationQuerier withClassName(String className) { - this.queryParams.put("collection", className); - return this; - } - - public ReplicationQuerier withShard(String shard) { - this.queryParams.put("shard", shard); - return this; - } - - public ReplicationQuerier withTargetNode(String targetNode) { - this.queryParams.put("targetNode", targetNode); - return this; - } - - public ReplicationQuerier withIncludeHistory(boolean includeHistory) { - this.queryParams.put("includeHistory", includeHistory); - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - String path = "/replication/replicate/list"; - - List query = new ArrayList<>(); - for (Entry qp : queryParams.entrySet()) { - query.add(UrlEncoder.encodeQueryParam(qp.getKey(), qp.getValue().toString())); - } - - if (!query.isEmpty()) { - path += "?" + String.join("&", query); - } - return sendGetRequest(path, callback, Result.toListParser(ReplicateOperation[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/Data.java b/src/main/java/io/weaviate/client/v1/async/data/Data.java deleted file mode 100644 index bcf030773..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/Data.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.weaviate.client.v1.async.data; - -import io.weaviate.client.Config; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.async.data.api.ObjectCreator; -import io.weaviate.client.v1.async.data.api.ObjectDeleter; -import io.weaviate.client.v1.async.data.api.ObjectUpdater; -import io.weaviate.client.v1.async.data.api.ObjectValidator; -import io.weaviate.client.v1.async.data.api.ObjectsChecker; -import io.weaviate.client.v1.async.data.api.ObjectsGetter; -import io.weaviate.client.v1.async.data.api.ReferenceCreator; -import io.weaviate.client.v1.async.data.api.ReferenceDeleter; -import io.weaviate.client.v1.async.data.api.ReferenceReplacer; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.builder.ReferencePayloadBuilder; -import io.weaviate.client.v1.data.util.ObjectsPath; -import io.weaviate.client.v1.data.util.ReferencesPath; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -public class Data { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - private final ObjectsPath objectsPath; - private final ReferencesPath referencesPath; - private final BeaconPath beaconPath; - - public Data(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, DbVersionSupport dbVersionSupport) { - this.client = client; - this.config = config; - this.tokenProvider = tokenProvider; - this.objectsPath = new ObjectsPath(dbVersionSupport); - this.referencesPath = new ReferencesPath(dbVersionSupport); - this.beaconPath = new BeaconPath(dbVersionSupport); - } - - public ObjectCreator creator() { - return new ObjectCreator(client, config, tokenProvider, objectsPath); - } - - public ObjectsGetter objectsGetter() { - return new ObjectsGetter(client, config, tokenProvider, objectsPath); - } - - public ObjectsChecker checker() { - return new ObjectsChecker(client, config, tokenProvider, objectsPath); - } - - public ObjectDeleter deleter() { - return new ObjectDeleter(client, config, tokenProvider, objectsPath); - } - - public ObjectUpdater updater() { - return new ObjectUpdater(client, config, tokenProvider, objectsPath); - } - - public ObjectValidator validator() { - return new ObjectValidator(client, config, tokenProvider); - } - - public ReferencePayloadBuilder referencePayloadBuilder() { - return new ReferencePayloadBuilder(beaconPath); - } - - public ReferenceCreator referenceCreator() { - return new ReferenceCreator(client, config, tokenProvider, referencesPath); - } - - public ReferenceReplacer referenceReplacer() { - return new ReferenceReplacer(client, config, tokenProvider, referencesPath); - } - - public ReferenceDeleter referenceDeleter() { - return new ReferenceDeleter(client, config, tokenProvider, referencesPath); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectCreator.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectCreator.java deleted file mode 100644 index 0578d6a2f..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectCreator.java +++ /dev/null @@ -1,99 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.Future; - -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; - -public class ObjectCreator extends AsyncBaseClient implements AsyncClientResult { - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private Map properties; - private Float[] vector; - private Map vectors; - private Map multiVectors; - - public ObjectCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, - ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - } - - public ObjectCreator withID(String id) { - this.id = id; - return this; - } - - public ObjectCreator withClassName(String className) { - this.className = className; - return this; - } - - public ObjectCreator withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectCreator withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectCreator withProperties(Map properties) { - this.properties = properties; - return this; - } - - public ObjectCreator withVector(Float[] vector) { - this.vector = vector; - return this; - } - - public ObjectCreator withVectors(Map vectors) { - this.vectors = vectors; - return this; - } - - public ObjectCreator withMultiVectors(Map multiVectors) { - this.multiVectors = multiVectors; - return this; - } - - private String getID() { - if (StringUtils.isEmpty(id)) { - return UUID.randomUUID().toString(); - } - return id; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = objectsPath.buildCreate(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .vector(vector) - .vectors(vectors) - .multiVectors(multiVectors) - .id(getID()) - .tenant(tenant) - .build(); - return sendPostRequest(path, obj, WeaviateObject.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectDeleter.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectDeleter.java deleted file mode 100644 index 56ab2bacf..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectDeleter.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.util.ObjectsPath; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ObjectDeleter extends AsyncBaseClient implements AsyncClientResult { - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - - public ObjectDeleter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - } - - public ObjectDeleter withID(String id) { - this.id = id; - return this; - } - - public ObjectDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - String path = objectsPath.buildDelete(ObjectsPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .build()); - return sendDeleteRequest(path, null, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectUpdater.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectUpdater.java deleted file mode 100644 index 08a317910..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectUpdater.java +++ /dev/null @@ -1,131 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.BooleanUtils; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; - -public class ObjectUpdater extends AsyncBaseClient implements AsyncClientResult { - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private Map properties; - private Float[] vector; - private Map vectors; - private Map multiVectors; - private Boolean withMerge; - - public ObjectUpdater(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, - ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - } - - public ObjectUpdater withID(String id) { - this.id = id; - return this; - } - - public ObjectUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ObjectUpdater withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectUpdater withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectUpdater withProperties(Map properties) { - this.properties = properties; - return this; - } - - public ObjectUpdater withVector(Float[] vector) { - this.vector = vector; - return this; - } - - public ObjectUpdater withVectors(Map vectors) { - this.vectors = vectors; - return this; - } - - public ObjectUpdater withMultiVectors(Map multiVectors) { - this.multiVectors = multiVectors; - return this; - } - - public ObjectUpdater withMerge() { - this.withMerge = true; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - String path = objectsPath.buildUpdate(ObjectsPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .build()); - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .id(id) - .vector(vector) - .vectors(vectors) - .multiVectors(multiVectors) - .tenant(tenant) - .build(); - if (BooleanUtils.isTrue(withMerge)) { - return sendPatchRequest(path, obj, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } - }); - } - return sendPutRequest(path, obj, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectValidator.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectValidator.java deleted file mode 100644 index ece3af985..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectValidator.java +++ /dev/null @@ -1,70 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.WeaviateObject; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ObjectValidator extends AsyncBaseClient implements AsyncClientResult { - private String id; - private String className; - private Map properties; - - public ObjectValidator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ObjectValidator withID(String id) { - this.id = id; - return this; - } - - public ObjectValidator withClassName(String className) { - this.className = className; - return this; - } - - public ObjectValidator withProperties(Map properties) { - this.properties = properties; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .id(id) - .build(); - return sendPostRequest("/objects/validate", obj, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsChecker.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsChecker.java deleted file mode 100644 index 19bacaf73..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsChecker.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.util.ObjectsPath; -import java.util.Collections; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -public class ObjectsChecker extends AsyncBaseClient implements AsyncClientResult { - private final ObjectsPath objectsPath; - private String id; - private String className; - private String tenant; - - public ObjectsChecker(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - } - - public ObjectsChecker withID(String id) { - this.id = id; - return this; - } - - public ObjectsChecker withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsChecker withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - String path = objectsPath.buildCheck(ObjectsPath.Params.builder() - .id(id) - .className(className) - .tenant(tenant) - .build()); - return sendHeadRequest(path, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), null, String.class); - switch (resp.getStatusCode()) { - case HttpStatus.SC_NO_CONTENT: - case HttpStatus.SC_NOT_FOUND: - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_NO_CONTENT, resp.getErrors()); - default: - WeaviateErrorResponse dummyError = WeaviateErrorResponse.builder().error(Collections.emptyList()).build(); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_NO_CONTENT, dummyError); - } - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsGetter.java b/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsGetter.java deleted file mode 100644 index 07becc4ac..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ObjectsGetter.java +++ /dev/null @@ -1,132 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.ObjectsListResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.concurrent.Future; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ObjectsGetter extends AsyncBaseClient> implements AsyncClientResult> { - private final ObjectsPath objectsPath; - private String id; - private String className; - private Integer limit; - private Integer offset; - private String after; - private final Set additional; - private String consistencyLevel; - private String tenant; - private String nodeName; - - public ObjectsGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ObjectsPath objectsPath) { - super(client, config, tokenProvider); - this.objectsPath = objectsPath; - this.additional = new HashSet<>(); - } - - public ObjectsGetter withID(String id) { - this.id = id; - return this; - } - - public ObjectsGetter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsGetter withLimit(Integer limit) { - this.limit = limit; - return this; - } - - public ObjectsGetter withVector() { - this.additional.add("vector"); - return this; - } - - public ObjectsGetter withAdditional(String name) { - this.additional.add(name); - return this; - } - - public ObjectsGetter withConsistencyLevel(String cl) { - this.consistencyLevel = cl; - return this; - } - - public ObjectsGetter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectsGetter withNodeName(String name) { - this.nodeName = name; - return this; - } - - public ObjectsGetter withAfter(String after) { - this.after = after; - return this; - } - - public ObjectsGetter withOffset(Integer offset) { - this.offset = offset; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - ObjectsPath.Params params = ObjectsPath.Params.builder() - .id(id) - .className(className) - .limit(limit) - .offset(offset) - .after(after) - .additional(additional.toArray(new String[0])) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .nodeName(nodeName) - .build(); - if (StringUtils.isNotBlank(id)) { - String path = objectsPath.buildGetOne(params); - return sendGetRequest(path, callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, WeaviateObject.class); - WeaviateObject object = resp.getBody(); - List objects = object == null - ? null - : Collections.singletonList(object); - return new Result<>(resp.getStatusCode(), objects, resp.getErrors()); - } - }); - } - String path = objectsPath.buildGet(params); - return sendGetRequest(path, callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, ObjectsListResponse.class); - List objects = resp.getBody() == null - ? null - : Arrays.asList(resp.getBody().getObjects()); - return new Result<>(resp.getStatusCode(), objects, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceCreator.java b/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceCreator.java deleted file mode 100644 index 47de4ff5d..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceCreator.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import java.util.Objects; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ReferenceCreator extends AsyncBaseClient implements AsyncClientResult { - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef referencePayload; - - public ReferenceCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath) { - super(client, config, tokenProvider); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceCreator withID(String id) { - this.id = id; - return this; - } - - public ReferenceCreator withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceCreator withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceCreator withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceCreator withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceCreator withReference(SingleRef referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = referencesPath.buildCreate(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - return sendPostRequest(path, referencePayload, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceDeleter.java b/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceDeleter.java deleted file mode 100644 index 97354f50a..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceDeleter.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import java.util.Objects; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ReferenceDeleter extends AsyncBaseClient implements AsyncClientResult { - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef referencePayload; - - public ReferenceDeleter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath) { - super(client, config, tokenProvider); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceDeleter withID(String id) { - this.id = id; - return this; - } - - public ReferenceDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceDeleter withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceDeleter withReference(SingleRef referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = referencesPath.buildDelete(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - return sendDeleteRequest(path, referencePayload, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceReplacer.java b/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceReplacer.java deleted file mode 100644 index 70103d6f5..000000000 --- a/src/main/java/io/weaviate/client/v1/async/data/api/ReferenceReplacer.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.async.data.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import java.util.Objects; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ReferenceReplacer extends AsyncBaseClient implements AsyncClientResult { - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef[] referencePayload; - - public ReferenceReplacer(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, ReferencesPath referencesPath) { - super(client, config, tokenProvider); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceReplacer withID(String id) { - this.id = id; - return this; - } - - public ReferenceReplacer withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceReplacer withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceReplacer withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceReplacer withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceReplacer withReferences(SingleRef... referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = referencesPath.buildReplace(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - return sendPutRequest(path, referencePayload, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/graphql/GraphQL.java b/src/main/java/io/weaviate/client/v1/async/graphql/GraphQL.java deleted file mode 100644 index 5b75fc8a2..000000000 --- a/src/main/java/io/weaviate/client/v1/async/graphql/GraphQL.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.async.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.graphql.api.Aggregate; -import io.weaviate.client.v1.async.graphql.api.Explore; -import io.weaviate.client.v1.async.graphql.api.Get; -import io.weaviate.client.v1.async.graphql.api.Raw; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -public class GraphQL { - private final Config config; - private final CloseableHttpAsyncClient client; - private final AccessTokenProvider tokenProvider; - - public GraphQL(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - this.client = client; - this.config = config; - this.tokenProvider = tokenProvider; - } - - public Get get() { - return new Get(client, config, tokenProvider); - } - - public Raw raw() { - return new Raw(client, config, tokenProvider); - } - - public Explore explore() { - return new Explore(client, config, tokenProvider); - } - - public Aggregate aggregate() { - return new Aggregate(client, config, tokenProvider); - } - - public io.weaviate.client.v1.graphql.GraphQL.Arguments arguments() { - return new io.weaviate.client.v1.graphql.GraphQL.Arguments(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/graphql/api/Aggregate.java b/src/main/java/io/weaviate/client/v1/async/graphql/api/Aggregate.java deleted file mode 100644 index bd616c241..000000000 --- a/src/main/java/io/weaviate/client/v1/async/graphql/api/Aggregate.java +++ /dev/null @@ -1,127 +0,0 @@ -package io.weaviate.client.v1.async.graphql.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.*; -import io.weaviate.client.v1.graphql.query.builder.AggregateBuilder; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public class Aggregate extends AsyncBaseClient implements AsyncClientResult { - private final AggregateBuilder.AggregateBuilderBuilder aggregateBuilder; - - public Aggregate(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - aggregateBuilder = AggregateBuilder.builder(); - } - - public Aggregate withClassName(String className) { - aggregateBuilder.className(className); - return this; - } - - public Aggregate withFields(Field... fields) { - aggregateBuilder.fields(Fields.builder() - .fields(fields) - .build()); - return this; - } - - @Deprecated - public Aggregate withWhere(WhereFilter where) { - return withWhere(WhereArgument.builder() - .filter(where) - .build()); - } - - public Aggregate withWhere(WhereArgument where) { - aggregateBuilder.withWhereFilter(where); - return this; - } - - public Aggregate withGroupBy(String propertyName) { - aggregateBuilder.groupByClausePropertyName(propertyName); - return this; - } - - public Aggregate withAsk(AskArgument ask) { - aggregateBuilder.withAskArgument(ask); - return this; - } - - public Aggregate withNearText(NearTextArgument withNearTextFilter) { - aggregateBuilder.withNearTextFilter(withNearTextFilter); - return this; - } - - public Aggregate withNearObject(NearObjectArgument withNearObjectFilter) { - aggregateBuilder.withNearObjectFilter(withNearObjectFilter); - return this; - } - - public Aggregate withNearVector(NearVectorArgument withNearVectorFilter) { - aggregateBuilder.withNearVectorFilter(withNearVectorFilter); - return this; - } - - public Aggregate withNearImage(NearImageArgument nearImage) { - aggregateBuilder.withNearImageFilter(nearImage); - return this; - } - - public Aggregate withNearAudio(NearAudioArgument nearAudio) { - aggregateBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Aggregate withNearVideo(NearVideoArgument nearVideo) { - aggregateBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Aggregate withNearDepth(NearDepthArgument nearDepth) { - aggregateBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Aggregate withNearThermal(NearThermalArgument nearThermal) { - aggregateBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Aggregate withNearImu(NearImuArgument nearImu) { - aggregateBuilder.withNearImuFilter(nearImu); - return this; - } - - public Aggregate withObjectLimit(Integer objectLimit) { - aggregateBuilder.objectLimit(objectLimit); - return this; - } - - public Aggregate withTenant(String tenant) { - aggregateBuilder.tenant(tenant); - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String aggregateQuery = aggregateBuilder.build() - .buildQuery(); - GraphQLQuery query = GraphQLQuery.builder() - .query(aggregateQuery) - .build(); - return sendPostRequest("/graphql", query, GraphQLResponse.class, callback); - } - -} diff --git a/src/main/java/io/weaviate/client/v1/async/graphql/api/Explore.java b/src/main/java/io/weaviate/client/v1/async/graphql/api/Explore.java deleted file mode 100644 index b8b8f5ead..000000000 --- a/src/main/java/io/weaviate/client/v1/async/graphql/api/Explore.java +++ /dev/null @@ -1,100 +0,0 @@ -package io.weaviate.client.v1.async.graphql.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.graphql.model.ExploreFields; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.*; -import io.weaviate.client.v1.graphql.query.builder.ExploreBuilder; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public class Explore extends AsyncBaseClient implements AsyncClientResult { - private final ExploreBuilder.ExploreBuilderBuilder exploreBuilder; - - public Explore(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - exploreBuilder = ExploreBuilder.builder(); - } - - public Explore withFields(ExploreFields... fields) { - exploreBuilder.fields(fields); - return this; - } - - public Explore withLimit(Integer limit) { - exploreBuilder.limit(limit); - return this; - } - - public Explore withOffset(Integer offset) { - exploreBuilder.offset(offset); - return this; - } - - public Explore withAsk(AskArgument ask) { - exploreBuilder.withAskArgument(ask); - return this; - } - - public Explore withNearText(NearTextArgument nearText) { - exploreBuilder.withNearText(nearText); - return this; - } - - public Explore withNearObject(NearObjectArgument nearObject) { - exploreBuilder.withNearObjectFilter(nearObject); - return this; - } - - public Explore withNearVector(NearVectorArgument nearVector) { - exploreBuilder.withNearVectorFilter(nearVector); - return this; - } - - public Explore withNearImage(NearImageArgument nearImage) { - exploreBuilder.withNearImageFilter(nearImage); - return this; - } - - public Explore withNearAudio(NearAudioArgument nearAudio) { - exploreBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Explore withNearVideo(NearVideoArgument nearVideo) { - exploreBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Explore withNearDepth(NearDepthArgument nearDepth) { - exploreBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Explore withNearThermal(NearThermalArgument nearThermal) { - exploreBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Explore withNearImu(NearImuArgument nearImu) { - exploreBuilder.withNearImuFilter(nearImu); - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String exploreQuery = exploreBuilder.build() - .buildQuery(); - GraphQLQuery query = GraphQLQuery.builder() - .query(exploreQuery) - .build(); - return sendPostRequest("/graphql", query, GraphQLResponse.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/graphql/api/Get.java b/src/main/java/io/weaviate/client/v1/async/graphql/api/Get.java deleted file mode 100644 index 52da873bf..000000000 --- a/src/main/java/io/weaviate/client/v1/async/graphql/api/Get.java +++ /dev/null @@ -1,277 +0,0 @@ -package io.weaviate.client.v1.async.graphql.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseGraphQLClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLGetBaseObject; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArguments; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.builder.GetBuilder; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class Get extends AsyncBaseGraphQLClient implements AsyncClientResult { - private final GetBuilder.GetBuilderBuilder getBuilder; - - public Get(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - getBuilder = GetBuilder.builder(); - } - - public Get withClassName(String className) { - getBuilder.className(className); - return this; - } - - public Get withFields(Field... fields) { - getBuilder.fields(Fields.builder() - .fields(fields) - .build()); - return this; - } - - @Deprecated - public Get withWhere(WhereFilter where) { - return withWhere(WhereArgument.builder() - .filter(where) - .build()); - } - - public Get withWhere(WhereArgument where) { - getBuilder.withWhereFilter(where); - return this; - } - - public Get withLimit(Integer limit) { - getBuilder.limit(limit); - return this; - } - - public Get withOffset(Integer offset) { - getBuilder.offset(offset); - return this; - } - - public Get withAfter(String after) { - getBuilder.after(after); - return this; - } - - public Get withBm25(Bm25Argument bm25) { - getBuilder.withBm25Filter(bm25); - return this; - } - - public Get withHybrid(HybridArgument hybrid) { - getBuilder.withHybridFilter(hybrid); - return this; - } - - public Get withAsk(AskArgument ask) { - getBuilder.withAskArgument(ask); - return this; - } - - public Get withNearText(NearTextArgument nearText) { - getBuilder.withNearTextFilter(nearText); - return this; - } - - public Get withNearObject(NearObjectArgument nearObject) { - getBuilder.withNearObjectFilter(nearObject); - return this; - } - - public Get withNearVector(NearVectorArgument nearVector) { - getBuilder.withNearVectorFilter(nearVector); - return this; - } - - public Get withNearImage(NearImageArgument nearImage) { - getBuilder.withNearImageFilter(nearImage); - return this; - } - - public Get withNearAudio(NearAudioArgument nearAudio) { - getBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Get withNearVideo(NearVideoArgument nearVideo) { - getBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Get withNearDepth(NearDepthArgument nearDepth) { - getBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Get withNearThermal(NearThermalArgument nearThermal) { - getBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Get withNearImu(NearImuArgument nearImu) { - getBuilder.withNearImuFilter(nearImu); - return this; - } - - public Get withGroup(GroupArgument group) { - getBuilder.withGroupArgument(group); - return this; - } - - public Get withSort(SortArgument... sort) { - getBuilder.withSortArguments(SortArguments.builder() - .sort(sort) - .build()); - return this; - } - - public Get withGenerativeSearch(GenerativeSearchBuilder generativeSearch) { - getBuilder.withGenerativeSearch(generativeSearch); - return this; - } - - public Get withConsistencyLevel(String level) { - getBuilder.withConsistencyLevel(level); - return this; - } - - public Get withGroupBy(GroupByArgument groupBy) { - getBuilder.withGroupByArgument(groupBy); - return this; - } - - public Get withTenant(String tenant) { - getBuilder.tenant(tenant); - return this; - } - - public Get withAutocut(Integer autocut) { - getBuilder.autocut(autocut); - return this; - } - - private GraphQLQuery getQuery() { - String getQuery = getBuilder.build() - .buildQuery(); - return GraphQLQuery.builder() - .query(getQuery) - .build(); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/graphql", getQuery(), GraphQLResponse.class, callback); - } - - /** - * This method provides a better way of serializing a GraphQL response using one's defined classes. - * Example: - * In Weaviate we have defined collection named Soup with name and price properties. - * For client to be able to properly serialize GraphQL response to an Object with - * convenient methods accessing GraphQL settings one can create a class, example: - *
{@code
-   * import com.google.gson.annotations.SerializedName;
-   *
-   * public class Soups {
-   *   {@literal @}SerializedName(value = "Soup")
-   *   List soups;
-   *
-   *   public List getSoups() {
-   *     return soups;
-   *   }
-   *
-   *   public static class Soup extends GraphQLGetBaseObject {
-   *     String name;
-   *     Float price;
-   *
-   *     public String getName() {
-   *       return name;
-   *     }
-   *
-   *     public Float getPrice() {
-   *       return price;
-   *     }
-   *   }
-   * }
-   * }
- * - * @param classOfC - class describing Weaviate object, example: Soups class - * @param - Class of C - * @return Result of GraphQLTypedResponse of a given class - * @see GraphQLGetBaseObject - */ - public Future>> run(final Class classOfC) { - return run(classOfC, null); - } - - /** - * This method provides a better way of serializing a GraphQL response using one's defined classes. - * Example: - * In Weaviate we have defined collection named Soup with name and price properties. - * For client to be able to properly serialize GraphQL response to an Object with - * convenient methods accessing GraphQL settings one can create a class, example: - *
{@code
-   * import com.google.gson.annotations.SerializedName;
-   *
-   * public class Soups {
-   *   {@literal @}SerializedName(value = "Soup")
-   *   List soups;
-   *
-   *   public List getSoups() {
-   *     return soups;
-   *   }
-   *
-   *   public static class Soup extends GraphQLGetBaseObject {
-   *     String name;
-   *     Float price;
-   *
-   *     public String getName() {
-   *       return name;
-   *     }
-   *
-   *     public Float getPrice() {
-   *       return price;
-   *     }
-   *   }
-   * }
-   * }
- * - * @param classOfC - class describing Weaviate object, example: Soups class - * @param callback - Result of GraphQLTypedResponse of a given class callback - * @param - Class of C - * @return Result of GraphQLTypedResponse of a given class - * @see GraphQLGetBaseObject - */ - public Future>> run(final Class classOfC, FutureCallback>> callback) { - return sendGraphQLTypedRequest(getQuery(), classOfC, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/graphql/api/Raw.java b/src/main/java/io/weaviate/client/v1/async/graphql/api/Raw.java deleted file mode 100644 index a117642fd..000000000 --- a/src/main/java/io/weaviate/client/v1/async/graphql/api/Raw.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.async.graphql.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import java.util.concurrent.Future; - -public class Raw extends AsyncBaseClient implements AsyncClientResult { - private String query; - - public Raw(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public Raw withQuery(String query) { - this.query = query; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - GraphQLQuery query = GraphQLQuery.builder() - .query(this.query) - .build(); - return sendPostRequest("/graphql", query, GraphQLResponse.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/Groups.java b/src/main/java/io/weaviate/client/v1/async/groups/Groups.java deleted file mode 100644 index c9f15e443..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/Groups.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.async.groups; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Groups { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public OidcGroups oidc() { - return new OidcGroups(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/OidcGroups.java b/src/main/java/io/weaviate/client/v1/async/groups/OidcGroups.java deleted file mode 100644 index 819a433b6..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/OidcGroups.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.async.groups; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.groups.api.oidc.AssignedRolesGetter; -import io.weaviate.client.v1.async.groups.api.oidc.KnownGroupNamesGetter; -import io.weaviate.client.v1.async.groups.api.oidc.RoleAssigner; -import io.weaviate.client.v1.async.groups.api.oidc.RoleRevoker; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class OidcGroups { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public RoleAssigner roleAssigner() { - return new RoleAssigner(client, config, tokenProvider); - } - - public RoleRevoker roleRevoker() { - return new RoleRevoker(client, config, tokenProvider); - } - - public AssignedRolesGetter assignedRolesGetter() { - return new AssignedRolesGetter(client, config, tokenProvider); - } - - public KnownGroupNamesGetter knownGroupNamesGetter() { - return new KnownGroupNamesGetter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/AssignedRolesGetter.java b/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/AssignedRolesGetter.java deleted file mode 100644 index 798153763..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/AssignedRolesGetter.java +++ /dev/null @@ -1,48 +0,0 @@ -package io.weaviate.client.v1.async.groups.api.oidc; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class AssignedRolesGetter extends AsyncBaseClient> implements AsyncClientResult> { - private String groupId; - private boolean includePermissions = false; - - public AssignedRolesGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AssignedRolesGetter withGroupId(String id) { - this.groupId = id; - return this; - } - - public AssignedRolesGetter includePermissions(boolean include) { - this.includePermissions = include; - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, Result.arrayToListParser(WeaviateRole[].class, WeaviateRole::toRole)); - } - - private String path() { - return String.format("/authz/groups/%s/roles/oidc?includeFullRoles=%s", encodeGroupId(), includePermissions); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/KnownGroupNamesGetter.java b/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/KnownGroupNamesGetter.java deleted file mode 100644 index ed1cfc575..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/KnownGroupNamesGetter.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.async.groups.api.oidc; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class KnownGroupNamesGetter extends AsyncBaseClient> implements AsyncClientResult> { - - public KnownGroupNamesGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - static class ResponseBody { - List aliases; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest("/authz/groups/oidc", callback, Result.arrayToListParser(String[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleAssigner.java b/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleAssigner.java deleted file mode 100644 index 45863841e..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleAssigner.java +++ /dev/null @@ -1,61 +0,0 @@ -package io.weaviate.client.v1.async.groups.api.oidc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AllArgsConstructor; - -public class RoleAssigner extends AsyncBaseClient implements AsyncClientResult { - private String groupId; - private List roles = new ArrayList<>(); - - public RoleAssigner(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public RoleAssigner withGroupId(String id) { - this.groupId = id; - return this; - } - - public RoleAssigner witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - @SerializedName("roles") - final List roles; - @SerializedName("groupType") - final String groupType = "oidc"; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest(path(), new Body(this.roles), callback, - Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/groups/%s/assign", encodeGroupId()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleRevoker.java b/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleRevoker.java deleted file mode 100644 index 09058e1b4..000000000 --- a/src/main/java/io/weaviate/client/v1/async/groups/api/oidc/RoleRevoker.java +++ /dev/null @@ -1,61 +0,0 @@ -package io.weaviate.client.v1.async.groups.api.oidc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AllArgsConstructor; - -public class RoleRevoker extends AsyncBaseClient implements AsyncClientResult { - private String groupId; - private List roles = new ArrayList<>(); - - public RoleRevoker(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public RoleRevoker withGroupId(String id) { - this.groupId = id; - return this; - } - - public RoleRevoker witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - @SerializedName("roles") - final List roles; - @SerializedName("groupType") - final String groupType = "oidc"; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest(path(), new Body(this.roles), callback, - Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/groups/%s/revoke", encodeGroupId()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/misc/Misc.java b/src/main/java/io/weaviate/client/v1/async/misc/Misc.java deleted file mode 100644 index 72cb0ddd5..000000000 --- a/src/main/java/io/weaviate/client/v1/async/misc/Misc.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.async.misc; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.misc.api.LiveChecker; -import io.weaviate.client.v1.async.misc.api.MetaGetter; -import io.weaviate.client.v1.async.misc.api.OpenIDConfigGetter; -import io.weaviate.client.v1.async.misc.api.ReadyChecker; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -public class Misc { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public Misc(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - this.client = client; - this.config = config; - this.tokenProvider = tokenProvider; - } - - public MetaGetter metaGetter() { - return new MetaGetter(client, config, tokenProvider); - } - - public OpenIDConfigGetter openIDConfigGetter() { - return new OpenIDConfigGetter(client, config, tokenProvider); - } - - public LiveChecker liveChecker() { - return new LiveChecker(client, config, tokenProvider); - } - - public ReadyChecker readyChecker() { - return new ReadyChecker(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/misc/api/LiveChecker.java b/src/main/java/io/weaviate/client/v1/async/misc/api/LiveChecker.java deleted file mode 100644 index 1bffd8535..000000000 --- a/src/main/java/io/weaviate/client/v1/async/misc/api/LiveChecker.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.v1.async.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class LiveChecker extends AsyncBaseClient implements AsyncClientResult { - - public LiveChecker(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/.well-known/live", callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/misc/api/MetaGetter.java b/src/main/java/io/weaviate/client/v1/async/misc/api/MetaGetter.java deleted file mode 100644 index 8ef7ed315..000000000 --- a/src/main/java/io/weaviate/client/v1/async/misc/api/MetaGetter.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.client.v1.async.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.misc.model.Meta; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class MetaGetter extends AsyncBaseClient implements AsyncClientResult { - - public MetaGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/meta", Meta.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/misc/api/OpenIDConfigGetter.java b/src/main/java/io/weaviate/client/v1/async/misc/api/OpenIDConfigGetter.java deleted file mode 100644 index 8730887b7..000000000 --- a/src/main/java/io/weaviate/client/v1/async/misc/api/OpenIDConfigGetter.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.client.v1.async.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.misc.model.OpenIDConfiguration; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class OpenIDConfigGetter extends AsyncBaseClient implements AsyncClientResult { - - public OpenIDConfigGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/meta", OpenIDConfiguration.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/misc/api/ReadyChecker.java b/src/main/java/io/weaviate/client/v1/async/misc/api/ReadyChecker.java deleted file mode 100644 index 9c827d31c..000000000 --- a/src/main/java/io/weaviate/client/v1/async/misc/api/ReadyChecker.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.v1.async.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ReadyChecker extends AsyncBaseClient implements AsyncClientResult { - - public ReadyChecker(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/.well-known/ready", callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/Roles.java b/src/main/java/io/weaviate/client/v1/async/rbac/Roles.java deleted file mode 100644 index 24ea6ebd6..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/Roles.java +++ /dev/null @@ -1,103 +0,0 @@ -package io.weaviate.client.v1.async.rbac; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.rbac.api.AssignedUsersGetter; -import io.weaviate.client.v1.async.rbac.api.GroupAssignmentsGetter; -import io.weaviate.client.v1.async.rbac.api.PermissionAdder; -import io.weaviate.client.v1.async.rbac.api.PermissionChecker; -import io.weaviate.client.v1.async.rbac.api.PermissionRemover; -import io.weaviate.client.v1.async.rbac.api.RoleAllGetter; -import io.weaviate.client.v1.async.rbac.api.RoleCreator; -import io.weaviate.client.v1.async.rbac.api.RoleDeleter; -import io.weaviate.client.v1.async.rbac.api.RoleExists; -import io.weaviate.client.v1.async.rbac.api.RoleGetter; -import io.weaviate.client.v1.async.rbac.api.UserAssignmentsGetter; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Roles { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - public RoleCreator creator() { - return new RoleCreator(client, config, tokenProvider); - } - - /** Get all existing roles. */ - public RoleDeleter deleter() { - return new RoleDeleter(client, config, tokenProvider); - } - - /** - * Add permissions to an existing role. - * Note: This method is an upsert operation. If the permission already exists, - * it will be updated. If it does not exist, it will be created. - */ - public PermissionAdder permissionAdder() { - return new PermissionAdder(client, config, tokenProvider); - } - - /** - * Remove permissions from a role. - * Note: This method is a downsert operation. If the permission does not - * exist, it will be ignored. If these permissions are the only permissions of - * the role, the role will be deleted. - */ - public PermissionRemover permissionRemover() { - return new PermissionRemover(client, config, tokenProvider); - } - - /** Check if a role has a permission. */ - public PermissionChecker permissionChecker() { - return new PermissionChecker(client, config, tokenProvider); - } - - /** Get all existing roles. */ - public RoleAllGetter allGetter() { - return new RoleAllGetter(client, config, tokenProvider); - }; - - /** Get role and its assiciated permissions. */ - public RoleGetter getter() { - return new RoleGetter(client, config, tokenProvider); - } - - /** - * Get users assigned to a role. - *

- * Deprecated - prefer {@link #userAssignmentsGetter()}. - */ - @Deprecated - public AssignedUsersGetter assignedUsersGetter() { - return new AssignedUsersGetter(client, config, tokenProvider); - } - - /** - * Get role assignments. - * - *

- * Note, that the result is not a list of unique users, - * but rather a list of all username+namespace combinations - * allowed for this role. - * In clusters with enabled OIDC authorization, users created dynamically - * (db_user) or configured in the environment (db_env_user) will appear twice: - * once as 'db_*' user and once as 'oidc' user. - */ - public UserAssignmentsGetter userAssignmentsGetter() { - return new UserAssignmentsGetter(client, config, tokenProvider); - } - - public GroupAssignmentsGetter groupAssignmentsGetter() { - return new GroupAssignmentsGetter(client, config, tokenProvider); - } - - /** Check if a role exists. */ - public RoleExists exists() { - return new RoleExists(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/AssignedUsersGetter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/AssignedUsersGetter.java deleted file mode 100644 index f523b8069..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/AssignedUsersGetter.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class AssignedUsersGetter extends AsyncBaseClient> implements AsyncClientResult> { - private String role; - - public AssignedUsersGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public AssignedUsersGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, String[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(new ArrayList<>()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - }); - } - - private String path() { - return String.format("/authz/roles/%s/users", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/GroupAssignmentsGetter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/GroupAssignmentsGetter.java deleted file mode 100644 index c96f418c8..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/GroupAssignmentsGetter.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.model.GroupAssignment; - -public class GroupAssignmentsGetter extends AsyncBaseClient> - implements AsyncClientResult> { - private String role; - - public GroupAssignmentsGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public GroupAssignmentsGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, Result.arrayToListParser(GroupAssignment[].class)); - } - - private String path() { - return String.format("/authz/roles/%s/group-assignments", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionAdder.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionAdder.java deleted file mode 100644 index 939f6241a..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionAdder.java +++ /dev/null @@ -1,62 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviatePermission; -import io.weaviate.client.v1.rbac.model.Permission; -import lombok.AllArgsConstructor; - -public class PermissionAdder extends AsyncBaseClient implements AsyncClientResult { - private String role; - private List> permissions = new ArrayList<>(); - - public PermissionAdder(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public PermissionAdder withRole(String name) { - this.role = name; - return this; - } - - public PermissionAdder withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - public PermissionAdder withPermissions(Permission[]... permissions) { - List> all = new ArrayList<>(); - for (Permission[] perm : permissions) { - all.addAll(Arrays.asList(perm)); - } - this.permissions = all; - return this; - } - - /** The API signature for this method is { "permissions": [...] } */ - @AllArgsConstructor - private static class Body { - public final List permissions; - } - - @Override - public Future> run(FutureCallback> callback) { - List permissions = WeaviatePermission.mergePermissions(this.permissions); - return sendPostRequest(path(), new Body(permissions), callback, Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/roles/%s/add-permissions", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionChecker.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionChecker.java deleted file mode 100644 index ae5b0950b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionChecker.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.model.Permission; - -public class PermissionChecker extends AsyncBaseClient implements AsyncClientResult { - private String role; - private Permission permission; - - public PermissionChecker(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public PermissionChecker withRole(String role) { - this.role = role; - return this; - } - - public PermissionChecker withPermission(Permission permission) { - this.permission = permission; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest(path(), permission.firstToWeaviate(), Boolean.class, callback); - } - - private String path() { - return String.format("/authz/roles/%s/has-permission", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionRemover.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionRemover.java deleted file mode 100644 index ad7961f75..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/PermissionRemover.java +++ /dev/null @@ -1,62 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviatePermission; -import io.weaviate.client.v1.rbac.model.Permission; -import lombok.AllArgsConstructor; - -public class PermissionRemover extends AsyncBaseClient implements AsyncClientResult { - private String role; - private List> permissions = new ArrayList<>(); - - public PermissionRemover(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public PermissionRemover withRole(String role) { - this.role = role; - return this; - } - - public PermissionRemover withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - public PermissionRemover withPermissions(Permission[]... permissions) { - List> all = new ArrayList<>(); - for (Permission[] perm : permissions) { - all.addAll(Arrays.asList(perm)); - } - this.permissions = all; - return this; - } - - /** The API signature for this method is { "permissions": [...] } */ - @AllArgsConstructor - private static class Body { - public final List permissions; - } - - @Override - public Future> run(FutureCallback> callback) { - List permissions = WeaviatePermission.mergePermissions(this.permissions); - return sendPostRequest(path(), new Body(permissions), callback, Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/roles/%s/remove-permissions", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleAllGetter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleAllGetter.java deleted file mode 100644 index 376683697..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleAllGetter.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.concurrent.Future; -import java.util.stream.Collectors; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleAllGetter extends AsyncBaseClient> implements AsyncClientResult> { - - public RoleAllGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest("/authz/roles", callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateRole[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(new ArrayList<>()) - .stream() - .map(w -> w.toRole()) - .collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleCreator.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleCreator.java deleted file mode 100644 index a952d9300..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleCreator.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Permission; - -public class RoleCreator extends AsyncBaseClient implements AsyncClientResult { - private String name; - private List> permissions = new ArrayList<>(); - - public RoleCreator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public RoleCreator withName(String name) { - this.name = name; - return this; - } - - public RoleCreator withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - public RoleCreator withPermissions(Permission[]... permissions) { - List> all = new ArrayList<>(); - for (Permission[] perm : permissions) { - all.addAll(Arrays.asList(perm)); - } - this.permissions = all; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - WeaviateRole role = new WeaviateRole(this.name, this.permissions); - return sendPostRequest("/authz/roles", role, callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleDeleter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleDeleter.java deleted file mode 100644 index da495467f..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleDeleter.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class RoleDeleter extends AsyncBaseClient implements AsyncClientResult { - private String name; - - public RoleDeleter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public RoleDeleter withName(String name) { - this.name = name; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendDeleteRequest("/authz/roles/" + this.name, null, callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleExists.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleExists.java deleted file mode 100644 index 1cd1dd71b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleExists.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleExists extends AsyncBaseClient implements AsyncClientResult { - private final RoleGetter getter; - - public RoleExists(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - this.getter = new RoleGetter(httpClient, config, tokenProvider); - } - - public RoleExists withName(String name) { - this.getter.withName(name); - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return CompletableFuture.supplyAsync(() -> { - try { - Result resp = this.getter.run().get(); - if (resp.hasErrors()) { - WeaviateError error = resp.getError(); - return new Result<>(error.getStatusCode(), null, - WeaviateErrorResponse.builder().error(error.getMessages()).build()); - } - return new Result(HttpStatus.SC_OK, resp.getResult() != null, null); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleGetter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleGetter.java deleted file mode 100644 index eaee97721..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/RoleGetter.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.Optional; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleGetter extends AsyncBaseClient implements AsyncClientResult { - private String name; - - public RoleGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public RoleGetter withName(String name) { - this.name = name; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/authz/roles/" + this.name, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateRole.class); - Role role = Optional.ofNullable(resp.getBody()).map(WeaviateRole::toRole).orElse(null); - return new Result<>(resp.getStatusCode(), role, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/rbac/api/UserAssignmentsGetter.java b/src/main/java/io/weaviate/client/v1/async/rbac/api/UserAssignmentsGetter.java deleted file mode 100644 index fb4abd3dc..000000000 --- a/src/main/java/io/weaviate/client/v1/async/rbac/api/UserAssignmentsGetter.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.async.rbac.api; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.model.UserAssignment; - -public class UserAssignmentsGetter extends AsyncBaseClient> - implements AsyncClientResult> { - private String role; - - public UserAssignmentsGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public UserAssignmentsGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, Result.arrayToListParser(UserAssignment[].class)); - } - - private String path() { - return String.format("/authz/roles/%s/user-assignments", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/Schema.java b/src/main/java/io/weaviate/client/v1/async/schema/Schema.java deleted file mode 100644 index 1b95e9357..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/Schema.java +++ /dev/null @@ -1,108 +0,0 @@ -package io.weaviate.client.v1.async.schema; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.async.schema.api.ClassCreator; -import io.weaviate.client.v1.async.schema.api.ClassDeleter; -import io.weaviate.client.v1.async.schema.api.ClassExists; -import io.weaviate.client.v1.async.schema.api.ClassGetter; -import io.weaviate.client.v1.async.schema.api.ClassUpdater; -import io.weaviate.client.v1.async.schema.api.PropertyCreator; -import io.weaviate.client.v1.async.schema.api.SchemaDeleter; -import io.weaviate.client.v1.async.schema.api.SchemaGetter; -import io.weaviate.client.v1.async.schema.api.ShardUpdater; -import io.weaviate.client.v1.async.schema.api.ShardsGetter; -import io.weaviate.client.v1.async.schema.api.ShardsUpdater; -import io.weaviate.client.v1.async.schema.api.TenantsCreator; -import io.weaviate.client.v1.async.schema.api.TenantsDeleter; -import io.weaviate.client.v1.async.schema.api.TenantsExists; -import io.weaviate.client.v1.async.schema.api.TenantsGetter; -import io.weaviate.client.v1.async.schema.api.TenantsUpdater; -import io.weaviate.client.v1.async.schema.api.VectorAdder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class Schema { - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - private final DbVersionSupport dbVersionSupport; - - public Schema(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, - DbVersionSupport dbVersionSupport) { - this.client = client; - this.config = config; - this.tokenProvider = tokenProvider; - this.dbVersionSupport = dbVersionSupport; - } - - public SchemaGetter getter() { - return new SchemaGetter(client, config, tokenProvider); - } - - public ClassGetter classGetter() { - return new ClassGetter(client, config, tokenProvider); - } - - public ClassExists exists() { - return new ClassExists(client, config, tokenProvider); - } - - public ClassCreator classCreator() { - return new ClassCreator(client, config, tokenProvider); - } - - public ClassUpdater classUpdater() { - return new ClassUpdater(client, config, tokenProvider); - } - - public ClassDeleter classDeleter() { - return new ClassDeleter(client, config, tokenProvider); - } - - public PropertyCreator propertyCreator() { - return new PropertyCreator(client, config, tokenProvider); - } - - public VectorAdder vectorAdder() { - return new VectorAdder(client, config, tokenProvider); - } - - public SchemaDeleter allDeleter() { - return new SchemaDeleter(new SchemaGetter(client, config, tokenProvider), - new ClassDeleter(client, config, tokenProvider)); - } - - public ShardsGetter shardsGetter() { - return new ShardsGetter(client, config, tokenProvider); - } - - public ShardUpdater shardUpdater() { - return new ShardUpdater(client, config, tokenProvider); - } - - public ShardsUpdater shardsUpdater() { - return new ShardsUpdater(client, config, tokenProvider); - } - - public TenantsCreator tenantsCreator() { - return new TenantsCreator(client, config, tokenProvider); - } - - public TenantsUpdater tenantsUpdater() { - return new TenantsUpdater(client, config, tokenProvider, dbVersionSupport); - } - - public TenantsExists tenantsExists() { - return new TenantsExists(client, config, tokenProvider); - } - - public TenantsGetter tenantsGetter() { - return new TenantsGetter(client, config, tokenProvider); - } - - public TenantsDeleter tenantsDeleter() { - return new TenantsDeleter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassCreator.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ClassCreator.java deleted file mode 100644 index ed351dbbb..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassCreator.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ClassCreator extends AsyncBaseClient implements AsyncClientResult { - - private WeaviateClass clazz; - - public ClassCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ClassCreator withClass(WeaviateClass clazz) { - this.clazz = clazz; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/schema", clazz, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateClass.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassDeleter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ClassDeleter.java deleted file mode 100644 index 809695059..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassDeleter.java +++ /dev/null @@ -1,52 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ClassDeleter extends AsyncBaseClient implements AsyncClientResult { - private String className; - - public ClassDeleter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ClassDeleter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - String path = String.format("/schema/%s", this.className); - return sendDeleteRequest(path, null, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassExists.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ClassExists.java deleted file mode 100644 index 8e0f73d04..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassExists.java +++ /dev/null @@ -1,58 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -public class ClassExists extends AsyncBaseClient implements AsyncClientResult { - private String className; - - public ClassExists(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ClassExists withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, null, errors)); - } - String path = String.format("/schema/%s", this.className); - return sendGetRequest(path, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Result getterClass = this.serializer.toResult(response.getCode(), body, WeaviateClass.class); - if (getterClass.hasErrors()) { - WeaviateError error = getterClass.getError(); - return new Result<>(error.getStatusCode(), null, WeaviateErrorResponse.builder().error(error.getMessages()).build()); - } - return new Result<>(HttpStatus.SC_OK, getterClass.getResult() != null, null); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassGetter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ClassGetter.java deleted file mode 100644 index cac8b473a..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassGetter.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class ClassGetter extends AsyncBaseClient implements AsyncClientResult { - - private String className; - - public ClassGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ClassGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, null, errors)); - } - String path = String.format("/schema/%s", this.className); - return sendGetRequest(path, WeaviateClass.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassUpdater.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ClassUpdater.java deleted file mode 100644 index b5183c834..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ClassUpdater.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class ClassUpdater extends AsyncBaseClient implements AsyncClientResult { - - private WeaviateClass clazz; - - public ClassUpdater(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ClassUpdater withClass(WeaviateClass clazz) { - this.clazz = clazz; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/schema/%s", UrlEncoder.encodePathParam(clazz.getClassName())); - return sendPutRequest(path, clazz, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateClass.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/PropertyCreator.java b/src/main/java/io/weaviate/client/v1/async/schema/api/PropertyCreator.java deleted file mode 100644 index 60ec1cd2d..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/PropertyCreator.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.Property; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class PropertyCreator extends AsyncBaseClient implements AsyncClientResult { - - private String className; - private Property property; - - public PropertyCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public PropertyCreator withClassName(String className) { - this.className = className; - return this; - } - - public PropertyCreator withProperty(Property property) { - this.property = property; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return CompletableFuture.completedFuture(new Result<>(500, false, errors)); - } - String path = String.format("/schema/%s/properties", this.className); - return sendPostRequest(path, property, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Property.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaDeleter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaDeleter.java deleted file mode 100644 index 2ab6c8442..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaDeleter.java +++ /dev/null @@ -1,70 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.stream.Collectors; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class SchemaDeleter implements AsyncClientResult { - - private final SchemaGetter schemaGetter; - private final ClassDeleter classDeleter; - - public SchemaDeleter(SchemaGetter schemaGetter, ClassDeleter classDeleter) { - this.schemaGetter = schemaGetter; - this.classDeleter = classDeleter; - } - - @Override - public Future> run(FutureCallback> callback) { - CompletableFuture> getSchema = CompletableFuture.supplyAsync(() -> { - try { - return schemaGetter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }); - CompletableFuture> deleteAll = getSchema.thenApplyAsync(schema -> { - if (schema.getError() != null) { - List errorMessages = schema.getError().getMessages().stream().map(err -> - WeaviateErrorMessage.builder().message(err.getMessage()).build() - ).collect(Collectors.toList()); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(errorMessages).build(); - return new Result<>(schema.getError().getStatusCode(), false, errors); - } else { - List weaviateClasses = schema.getResult().getClasses(); - for (WeaviateClass clazz : weaviateClasses) { - try { - Result result = classDeleter.withClassName(clazz.getClassName()).run().get(); - if (result.getError() != null) { - return result; - } - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - } - } - return new Result<>(200, true, null); - }); - - if (callback != null) { - return deleteAll.whenComplete((booleanResult, e) -> { - callback.completed(booleanResult); - if (e != null) { - callback.failed(new Exception(e)); - } - }); - } - return deleteAll; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaGetter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaGetter.java deleted file mode 100644 index abb1c8c06..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/SchemaGetter.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.Schema; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -public class SchemaGetter extends AsyncBaseClient implements AsyncClientResult { - - public SchemaGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/schema", Schema.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardUpdater.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ShardUpdater.java deleted file mode 100644 index 189deb996..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardUpdater.java +++ /dev/null @@ -1,70 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; - -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.schema.model.ShardStatus; - -public class ShardUpdater extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String shardName; - private ShardStatus status; - - public ShardUpdater(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ShardUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ShardUpdater withShardName(String shardName) { - this.shardName = shardName; - return this; - } - - public ShardUpdater withStatus(String targetStatus) { - this.status = ShardStatus.builder().status(targetStatus).build(); - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - List emptyFieldNames = new ArrayList<>(); - if (StringUtils.isEmpty(this.className)) { - emptyFieldNames.add("className"); - } - if (StringUtils.isEmpty(this.shardName)) { - emptyFieldNames.add("shardName"); - } - if (this.status == null) { - emptyFieldNames.add("status"); - } - if (emptyFieldNames.size() > 0) { - String message = String.format("%s cannot be empty", StringUtils.joinWith(", ", emptyFieldNames.toArray())); - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message(message).build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return CompletableFuture.completedFuture(new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors)); - } - String path = String.format("/schema/%s/shards/%s", this.className, this.shardName); - return sendPutRequest(path, status, ShardStatus.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsGetter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsGetter.java deleted file mode 100644 index df02215c1..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsGetter.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.Shard; -import java.util.Collections; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -public class ShardsGetter extends AsyncBaseClient implements AsyncClientResult { - private String className; - - public ShardsGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public ShardsGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("className cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return CompletableFuture.completedFuture(new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors)); - } - return sendGetRequest(String.format("/schema/%s/shards", this.className), Shard[].class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsUpdater.java b/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsUpdater.java deleted file mode 100644 index 8ed1fc67f..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/ShardsUpdater.java +++ /dev/null @@ -1,100 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; - -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.schema.model.Shard; -import io.weaviate.client.v1.schema.model.ShardStatus; - -public class ShardsUpdater extends AsyncBaseClient implements AsyncClientResult { - private final ShardsGetter shardsGetter; - private final ShardUpdater shardUpdater; - - private String className; - private String status; - - public ShardsUpdater(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - this.shardsGetter = new ShardsGetter(client, config, tokenProvider); - this.shardUpdater = new ShardUpdater(client, config, tokenProvider); - } - - public ShardsUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ShardsUpdater withStatus(String targetStatus) { - this.status = targetStatus; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - List emptyFieldNames = new ArrayList<>(); - if (StringUtils.isEmpty(this.className)) { - emptyFieldNames.add("className"); - } - if (this.status == null) { - emptyFieldNames.add("status"); - } - if (emptyFieldNames.size() > 0) { - String message = String.format("%s cannot be empty", StringUtils.joinWith(", ", emptyFieldNames.toArray())); - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder().message(message).build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder().error(Collections.singletonList(errorMessage)).build(); - return CompletableFuture.completedFuture(new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors)); - } - - CompletableFuture> updateAll = CompletableFuture.supplyAsync(() -> { - try { - Result shards = this.shardsGetter.withClassName(this.className).run().get(); - if (shards.hasErrors()) { - return shards.toErrorResult(); - } - - List shardStatuses = new ArrayList<>(); - for (Shard shard : shards.getResult()) { - Result update = this.shardUpdater - .withClassName(this.className) - .withShardName(shard.getName()) - .withStatus(this.status).run().get(); - if (update.hasErrors()) { - return update.toErrorResult(); - } - shardStatuses.add(update.getResult()); - } - - return new Result<>(HttpStatus.SC_OK, shardStatuses.toArray(new ShardStatus[shardStatuses.size()]), null); - } catch (ExecutionException | InterruptedException e) { - throw new CompletionException(e); - } - }); - - if (callback == null) { - return updateAll; - } - return updateAll.whenComplete((statuses, e) -> { - callback.completed(statuses); - if (e != null) { - callback.failed(new Exception(e)); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsCreator.java b/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsCreator.java deleted file mode 100644 index da65d6e7c..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsCreator.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.Tenant; - -public class TenantsCreator extends AsyncBaseClient implements AsyncClientResult { - private String className; - private Tenant[] tenants; - - public TenantsCreator(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public TenantsCreator withClassName(String className) { - this.className = className; - return this; - } - - public TenantsCreator withTenants(Tenant... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - - return sendPostRequest(path, tenants, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, Tenant[].class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsDeleter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsDeleter.java deleted file mode 100644 index 11ceddd22..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsDeleter.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsDeleter extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String[] tenants; - - public TenantsDeleter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public TenantsDeleter withClassName(String className) { - this.className = className; - return this; - } - - public TenantsDeleter withTenants(String... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - return sendDeleteRequest(path, tenants, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsExists.java b/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsExists.java deleted file mode 100644 index f6bf0fd08..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsExists.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsExists extends AsyncBaseClient implements AsyncClientResult { - private String className; - private String tenant; - - public TenantsExists(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public TenantsExists withClassName(String className) { - this.className = className; - return this; - } - - public TenantsExists withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - String path = String.format("/schema/%s/tenants/%s", UrlEncoder.encodePathParam(className), UrlEncoder.encodePathParam(tenant)); - return sendHeadRequest(path, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsGetter.java b/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsGetter.java deleted file mode 100644 index bd4c9aea9..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsGetter.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.Tenant; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.concurrent.Future; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -public class TenantsGetter extends AsyncBaseClient> implements AsyncClientResult> { - private String className; - - public TenantsGetter(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - } - - public TenantsGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - return sendGetRequest(path, callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, Tenant[].class); - List tenants = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(null); - return new Result<>(resp.getStatusCode(), tenants, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsUpdater.java b/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsUpdater.java deleted file mode 100644 index 769772401..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/TenantsUpdater.java +++ /dev/null @@ -1,94 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.Tenant; -import java.util.Collection; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsUpdater extends AsyncBaseClient implements AsyncClientResult { - - private final static int BATCH_SIZE = 100; - private final DbVersionSupport dbVersionSupport; - private String className; - private Tenant[] tenants; - - public TenantsUpdater(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider, DbVersionSupport dbVersionSupport) { - super(client, config, tokenProvider); - this.dbVersionSupport = dbVersionSupport; - } - - public TenantsUpdater withClassName(String className) { - this.className = className; - return this; - } - - public TenantsUpdater withTenants(Tenant... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - if (dbVersionSupport.supportsOnly100TenantsInOneRequest() && tenants != null && tenants.length > BATCH_SIZE) { - CompletableFuture> updateAll = CompletableFuture.supplyAsync(() -> chunkTenants(tenants, BATCH_SIZE)).thenApplyAsync(tenants -> { - for (List batch : tenants) { - try { - Result resp = updateTenants(batch.toArray(new Tenant[0]), null).get(); - if (resp.hasErrors()) { - return resp; - } - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - } - return new Result<>(200, true, null); - }); - if (callback != null) { - return updateAll.whenComplete((booleanResult, e) -> { - callback.completed(booleanResult); - if (e != null) { - callback.failed(new Exception(e)); - } - }); - } - return updateAll; - } - return updateTenants(tenants, callback); - } - - private Future> updateTenants(Tenant[] tenants, FutureCallback> callback) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - return sendPutRequest(path, tenants, callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, Tenant[].class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } - }); - } - - private Collection> chunkTenants(Tenant[] tenants, int chunkSize) { - AtomicInteger counter = new AtomicInteger(); - return Stream.of(tenants).collect(Collectors.groupingBy(it -> counter.getAndIncrement() / chunkSize)).values(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/schema/api/VectorAdder.java b/src/main/java/io/weaviate/client/v1/async/schema/api/VectorAdder.java deleted file mode 100644 index 40664c795..000000000 --- a/src/main/java/io/weaviate/client/v1/async/schema/api/VectorAdder.java +++ /dev/null @@ -1,96 +0,0 @@ -package io.weaviate.client.v1.async.schema.api; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.client.v1.schema.model.WeaviateClass.VectorConfig; - -public class VectorAdder extends AsyncBaseClient implements AsyncClientResult { - private final ClassGetter getter; - - private String className; - private Map addedVectors = new HashMap<>(); - - public VectorAdder(CloseableHttpAsyncClient client, Config config, AccessTokenProvider tokenProvider) { - super(client, config, tokenProvider); - this.getter = new ClassGetter(client, config, tokenProvider); - } - - public VectorAdder withClassName(String className) { - this.className = className; - return this; - } - - /** - * Add a named vectors. This method can be chained to add multiple named vectors - * without using a {@link Map}. - */ - public VectorAdder withVectorConfig(String name, VectorConfig vector) { - this.addedVectors.put(name, vector); - return this; - } - - /** - * Add all vectors from the map. This will overwrite any vectors added - * previously. - */ - public VectorAdder withVectorConfig(Map vectors) { - this.addedVectors = Collections.unmodifiableMap(vectors); - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - CompletableFuture> getClass = CompletableFuture.supplyAsync(() -> { - try { - return getter.withClassName(className).run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }); - CompletableFuture> addVectors = getClass.>thenApplyAsync(result -> { - if (result.getError() != null) { - return result.toErrorResult(); - } - WeaviateClass cls = result.getResult(); - addedVectors.entrySet().stream() - .forEach(vector -> cls.getVectorConfig() - .putIfAbsent(vector.getKey(), vector.getValue())); - - String path = String.format("/schema/%s", UrlEncoder.encodePathParam(className)); - try { - return sendPutRequest(path, cls, callback, new ResponseParser() { - - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateClass.class); - return new Result<>(response.getCode(), response.getCode() <= 299, resp.getErrors()); - } - }).get(); - } catch (InterruptedException | ExecutionException e) { - throw new CompletionException(e); - } - }); - - return addVectors; - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/DbUsers.java b/src/main/java/io/weaviate/client/v1/async/users/DbUsers.java deleted file mode 100644 index cdd52dc31..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/DbUsers.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.async.users; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.users.api.RoleAssigner; -import io.weaviate.client.v1.async.users.api.RoleRevoker; -import io.weaviate.client.v1.async.users.api.common.AssignedRolesGetter; -import io.weaviate.client.v1.async.users.api.db.Activator; -import io.weaviate.client.v1.async.users.api.db.AllGetter; -import io.weaviate.client.v1.async.users.api.db.ByNameGetter; -import io.weaviate.client.v1.async.users.api.db.Creator; -import io.weaviate.client.v1.async.users.api.db.Deactivator; -import io.weaviate.client.v1.async.users.api.db.Deleter; -import io.weaviate.client.v1.async.users.api.db.KeyRotator; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class DbUsers { - private static final String USER_TYPE = "db"; - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - /** Assign a role to a user. Note that 'root' cannot be assigned. */ - public RoleAssigner assigner() { - return new RoleAssigner(client, config, tokenProvider, USER_TYPE); - } - - /** Revoke a role from a user. Note that 'root' cannot be revoked. */ - public RoleRevoker revoker() { - return new RoleRevoker(client, config, tokenProvider, USER_TYPE); - } - - /** Get roles assigned to a user. */ - public AssignedRolesGetter userRolesGetter() { - return new AssignedRolesGetter(client, config, tokenProvider, USER_TYPE); - } - - /** Create a new user. Returns API key for the user to authenticate by. */ - public Creator creator() { - return new Creator(client, config, tokenProvider); - } - - /** - * Delete user. - * Users declared in the server environment config cannot be - * deleted ('db_env_user'). - */ - public Deleter deleter() { - return new Deleter(client, config, tokenProvider); - } - - /** Activate user account. */ - public Activator activator() { - return new Activator(client, config, tokenProvider); - } - - /** Deactivate user account, optionally revoking its API key. */ - public Deactivator deactivator() { - return new Deactivator(client, config, tokenProvider); - } - - /** Rotate user's API key. The old key will become invalid. */ - public KeyRotator keyRotator() { - return new KeyRotator(client, config, tokenProvider); - } - - /** Get information about the user. */ - public ByNameGetter getUser() { - return new ByNameGetter(client, config, tokenProvider); - } - - /** List all known (non-OIDC) users. */ - public AllGetter allGetter() { - return new AllGetter(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/OidcUsers.java b/src/main/java/io/weaviate/client/v1/async/users/OidcUsers.java deleted file mode 100644 index fd6abba99..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/OidcUsers.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.async.users; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.users.api.RoleAssigner; -import io.weaviate.client.v1.async.users.api.RoleRevoker; -import io.weaviate.client.v1.async.users.api.common.AssignedRolesGetter; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class OidcUsers { - private static final String USER_TYPE = "oidc"; - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - /** Assign a role to a user. Note that 'root' cannot be assigned. */ - public RoleAssigner assigner() { - return new RoleAssigner(client, config, tokenProvider, USER_TYPE); - } - - /** Revoke a role from a user. Note that 'root' cannot be revoked. */ - public RoleRevoker revoker() { - return new RoleRevoker(client, config, tokenProvider, USER_TYPE); - } - - /** Get roles assigned to a user. */ - public AssignedRolesGetter userRolesGetter() { - return new AssignedRolesGetter(client, config, tokenProvider, USER_TYPE); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/Users.java b/src/main/java/io/weaviate/client/v1/async/users/Users.java deleted file mode 100644 index 54e8ea47b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/Users.java +++ /dev/null @@ -1,67 +0,0 @@ -package io.weaviate.client.v1.async.users; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.users.api.MyUserGetter; -import io.weaviate.client.v1.async.users.api.RoleAssigner; -import io.weaviate.client.v1.async.users.api.RoleRevoker; -import io.weaviate.client.v1.async.users.api.UserRolesGetter; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Users { - - private final CloseableHttpAsyncClient client; - private final Config config; - private final AccessTokenProvider tokenProvider; - - /** Get information about the current user. */ - public MyUserGetter myUserGetter() { - return new MyUserGetter(client, config, tokenProvider); - }; - - /** - * Get roles assigned to a user. - *

- * Deprecated - prefer {@link DbUsers#userRolesGetter()} or - * {@link OidcUsers#userRolesGetter()}. - */ - @Deprecated - public UserRolesGetter userRolesGetter() { - return new UserRolesGetter(client, config, tokenProvider); - }; - - /** - * Assign a role to a user. Note that 'root' cannot be assigned. - *

- * Deprecated - prefer {@link DbUsers#assigner()} or - * {@link OidcUsers#assigner()}. - */ - @Deprecated - public RoleAssigner assigner() { - return new RoleAssigner(client, config, tokenProvider); - } - - /** - * Revoke a role from a user. Note that 'root' cannot be revoked. - *

- * Deprecated - prefer {@link DbUsers#revoker()} or - * {@link OidcUsers#revoker()} - */ - @Deprecated - public RoleRevoker revoker() { - return new RoleRevoker(client, config, tokenProvider); - } - - /** Manage dynamic users, their roles and permissions. */ - public DbUsers db() { - return new DbUsers(client, config, tokenProvider); - } - - /** Manage users authenticated via OIDC, their roles and permissions. */ - public OidcUsers oidc() { - return new OidcUsers(client, config, tokenProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/MyUserGetter.java b/src/main/java/io/weaviate/client/v1/async/users/api/MyUserGetter.java deleted file mode 100644 index 0c4a840e3..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/MyUserGetter.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.async.users.api; - -import java.util.Optional; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.users.api.WeaviateUser; -import io.weaviate.client.v1.users.model.User; - -public class MyUserGetter extends AsyncBaseClient implements AsyncClientResult { - public MyUserGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/users/own-info", callback, new ResponseParser() { - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateUser.class); - User user = Optional.ofNullable(resp.getBody()) - .map(WeaviateUser::toUser) - .orElse(null); - return new Result<>(resp.getStatusCode(), user, resp.getErrors()); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/RoleAssigner.java b/src/main/java/io/weaviate/client/v1/async/users/api/RoleAssigner.java deleted file mode 100644 index 38f6be9c9..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/RoleAssigner.java +++ /dev/null @@ -1,59 +0,0 @@ -package io.weaviate.client.v1.async.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AllArgsConstructor; - -public class RoleAssigner extends AsyncBaseClient implements AsyncClientResult { - private String userId; - private List roles = new ArrayList<>(); - - private final String _userType; - - public RoleAssigner(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - this(httpClient, config, tokenProvider, null); - } - - public RoleAssigner(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider, - String userType) { - super(httpClient, config, tokenProvider); - this._userType = userType; - } - - public RoleAssigner withUserId(String id) { - this.userId = id; - return this; - } - - public RoleAssigner witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - final String userType = _userType; // always inherit from the outer class - final List roles; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest(path(), new Body(this.roles), callback, Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/users/%s/assign", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/RoleRevoker.java b/src/main/java/io/weaviate/client/v1/async/users/api/RoleRevoker.java deleted file mode 100644 index 2ecee4f10..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/RoleRevoker.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.weaviate.client.v1.async.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AllArgsConstructor; - -public class RoleRevoker extends AsyncBaseClient implements AsyncClientResult { - private String userId; - private List roles = new ArrayList<>(); - - private final String _userType; - - public RoleRevoker(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - this(httpClient, config, tokenProvider, null); - } - - public RoleRevoker(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider, - String userType) { - super(httpClient, config, tokenProvider); - this._userType = userType; - } - - public RoleRevoker withUserId(String id) { - this.userId = id; - return this; - } - - public RoleRevoker witRoles(String... roles) { - this.roles = Collections.unmodifiableList(Arrays.asList(roles)); - return this; - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - final String userType = _userType; // always inherit from the outer class - final List roles; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest(path(), new Body(this.roles), callback, Result.voidToBooleanParser()); - } - - private String path() { - return String.format("/authz/users/%s/revoke", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/UserRolesGetter.java b/src/main/java/io/weaviate/client/v1/async/users/api/UserRolesGetter.java deleted file mode 100644 index 67d3d8024..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/UserRolesGetter.java +++ /dev/null @@ -1,58 +0,0 @@ -package io.weaviate.client.v1.async.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.concurrent.Future; -import java.util.stream.Collectors; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class UserRolesGetter extends AsyncBaseClient> implements AsyncClientResult> { - private String userId; - - public UserRolesGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - /** Leave unset to fetch roles assigned to the current user. */ - public UserRolesGetter withUserId(String id) { - this.userId = id; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, new ResponseParser>() { - @Override - public Result> parse(HttpResponse response, String body, ContentType contentType) { - Response resp = this.serializer.toResponse(response.getCode(), body, WeaviateRole[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(new ArrayList<>()) - .stream() - .map(w -> w.toRole()) - .collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - }); - } - - private String path() { - return String.format("/authz/users/%s/roles", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/common/AssignedRolesGetter.java b/src/main/java/io/weaviate/client/v1/async/users/api/common/AssignedRolesGetter.java deleted file mode 100644 index 356981e96..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/common/AssignedRolesGetter.java +++ /dev/null @@ -1,56 +0,0 @@ -package io.weaviate.client.v1.async.users.api.common; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class AssignedRolesGetter extends AsyncBaseClient> implements AsyncClientResult> { - private String userId; - private boolean includePermissions = false; - - private final String userType; - - public AssignedRolesGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider, - String userType) { - super(httpClient, config, tokenProvider); - this.userType = userType; - } - - public AssignedRolesGetter withUserId(String userId) { - this.userId = userId; - return this; - } - - /** - * Include a full list of permissions for each role. - * If not set, only role names will be populated. - */ - public AssignedRolesGetter includePermissions() { - return includePermissions(true); - } - - public AssignedRolesGetter includePermissions(boolean include) { - this.includePermissions = include; - return this; - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest(path(), callback, Result.arrayToListParser(WeaviateRole[].class, WeaviateRole::toRole)); - } - - private String path() { - return String.format("/authz/users/%s/roles/%s?includeFullRoles=%s", - userId, userType, includePermissions); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/Activator.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/Activator.java deleted file mode 100644 index b419b13d7..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/Activator.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class Activator extends AsyncBaseClient implements AsyncClientResult { - private String userId; - - public Activator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public Activator withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/users/db/" + userId + "/activate", null, callback, - Result.voidToBooleanParser(HttpStatus.SC_CONFLICT)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/AllGetter.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/AllGetter.java deleted file mode 100644 index f3fd02a94..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/AllGetter.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.List; -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.users.model.UserDb; - -public class AllGetter extends AsyncBaseClient> implements AsyncClientResult> { - - public AllGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - @Override - public Future>> run(FutureCallback>> callback) { - return sendGetRequest("/users/db", callback, Result.arrayToListParser(UserDb[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/ByNameGetter.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/ByNameGetter.java deleted file mode 100644 index c605d4900..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/ByNameGetter.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.users.model.UserDb; - -public class ByNameGetter extends AsyncBaseClient implements AsyncClientResult { - private String userId; - - public ByNameGetter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public ByNameGetter withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendGetRequest("/users/db/" + userId, UserDb.class, callback); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/Creator.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/Creator.java deleted file mode 100644 index 92556fbcb..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/Creator.java +++ /dev/null @@ -1,48 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -/** Creates a new 'db' user and returns its API key. */ -public class Creator extends AsyncBaseClient implements AsyncClientResult { - private String userId; - - public Creator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public Creator withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/users/db/" + userId, null, callback, new ResponseParser() { - class ApiKey { - @SerializedName("apikey") - String apiKey; - } - - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, ApiKey.class); - return new Result<>(resp, resp.getBody() != null ? resp.getBody().apiKey : null); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/Deactivator.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/Deactivator.java deleted file mode 100644 index 3534e3e5a..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/Deactivator.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.HttpStatus; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.AllArgsConstructor; - -public class Deactivator extends AsyncBaseClient implements AsyncClientResult { - private String userId; - private boolean revokeKey = false; - - public Deactivator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public Deactivator withUserId(String userId) { - this.userId = userId; - return this; - } - - public Deactivator revokeKey() { - return revokeKey(true); - } - - public Deactivator revokeKey(boolean revoke) { - this.revokeKey = revoke; - return this; - } - - @AllArgsConstructor - private class Body { - @SerializedName("revoke_key") - private boolean revokeKey; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/users/db/" + userId + "/deactivate", new Body(revokeKey), callback, - Result.voidToBooleanParser(HttpStatus.SC_CONFLICT)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/Deleter.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/Deleter.java deleted file mode 100644 index 35eb0793b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/Deleter.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class Deleter extends AsyncBaseClient implements AsyncClientResult { - private String userId; - - public Deleter(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public Deleter withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendDeleteRequest("/users/db/" + userId, null, callback, Result.voidToBooleanParser()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/async/users/api/db/KeyRotator.java b/src/main/java/io/weaviate/client/v1/async/users/api/db/KeyRotator.java deleted file mode 100644 index 5404d9c4b..000000000 --- a/src/main/java/io/weaviate/client/v1/async/users/api/db/KeyRotator.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.async.users.api.db; - -import java.util.concurrent.Future; - -import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; -import org.apache.hc.core5.concurrent.FutureCallback; -import org.apache.hc.core5.http.ContentType; -import org.apache.hc.core5.http.HttpResponse; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.AsyncBaseClient; -import io.weaviate.client.base.AsyncClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.async.ResponseParser; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class KeyRotator extends AsyncBaseClient implements AsyncClientResult { - private String userId; - - public KeyRotator(CloseableHttpAsyncClient httpClient, Config config, AccessTokenProvider tokenProvider) { - super(httpClient, config, tokenProvider); - } - - public KeyRotator withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Future> run(FutureCallback> callback) { - return sendPostRequest("/users/db/" + userId + "/rotate-key", null, callback, new ResponseParser() { - class ApiKey { - @SerializedName("apikey") - String apiKey; - } - - @Override - public Result parse(HttpResponse response, String body, ContentType contentType) { - Response resp = serializer.toResponse(response.getCode(), body, ApiKey.class); - return new Result<>(resp, resp.getBody().apiKey); - } - }); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/ApiKeyFlow.java b/src/main/java/io/weaviate/client/v1/auth/ApiKeyFlow.java deleted file mode 100644 index e8468b940..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/ApiKeyFlow.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.auth; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.v1.auth.exception.AuthException; -import lombok.RequiredArgsConstructor; - -import java.util.List; - -@RequiredArgsConstructor -public class ApiKeyFlow implements Authentication { - - private final String apiKey; - - @Override - public WeaviateClient getAuthClient(Config config, List scopes) throws AuthException { - return getAuthClient(config); - } - - @Override - public WeaviateClient getAuthClient(Config config) throws AuthException { - return new WeaviateClient(config, () -> apiKey); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/Authentication.java b/src/main/java/io/weaviate/client/v1/auth/Authentication.java deleted file mode 100644 index b278a33a5..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/Authentication.java +++ /dev/null @@ -1,11 +0,0 @@ -package io.weaviate.client.v1.auth; - -import io.weaviate.client.v1.auth.exception.AuthException; -import java.util.List; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; - -public interface Authentication { - WeaviateClient getAuthClient(Config config, List scopes) throws AuthException; - WeaviateClient getAuthClient(Config config) throws AuthException; -} diff --git a/src/main/java/io/weaviate/client/v1/auth/BearerTokenFlow.java b/src/main/java/io/weaviate/client/v1/auth/BearerTokenFlow.java deleted file mode 100644 index dbbb189c7..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/BearerTokenFlow.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.weaviate.client.v1.auth; - -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.nimbus.BaseAuth; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.auth.provider.AuthRefreshTokenProvider; -import java.util.List; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; - -public class BearerTokenFlow implements Authentication { - - private final NimbusAuth nimbusAuth; - private final String accessToken; - private final long accessTokenLifetime; - private final String refreshToken; - - public BearerTokenFlow(String accessToken, long accessTokenLifetime, String refreshToken) { - this.nimbusAuth = new NimbusAuth(); - this.accessToken = accessToken; - this.accessTokenLifetime = accessTokenLifetime; - this.refreshToken = refreshToken; - } - - @Override - public WeaviateClient getAuthClient(Config config, List scopes) throws AuthException { - if (StringUtils.isBlank(refreshToken)) { - nimbusAuth.logNoRefreshTokenWarning(accessTokenLifetime); - } - BaseAuth.AuthResponse authResponse = nimbusAuth.getIdAndTokenEndpoint(config); - AccessTokenProvider tokenProvider = new AuthRefreshTokenProvider(config, - authResponse, accessToken, accessTokenLifetime, refreshToken); - return new WeaviateClient(config, tokenProvider); - } - - @Override - public WeaviateClient getAuthClient(Config config) throws AuthException { - return getAuthClient(config, null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/ClientCredentialsFlow.java b/src/main/java/io/weaviate/client/v1/auth/ClientCredentialsFlow.java deleted file mode 100644 index 54790a4d1..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/ClientCredentialsFlow.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.auth; - -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.nimbus.AuthType; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.List; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; - -public class ClientCredentialsFlow implements Authentication { - - private final NimbusAuth nimbusAuth; - private final String clientSecret; - - public ClientCredentialsFlow(String clientSecret) { - this.nimbusAuth = new NimbusAuth(); - this.clientSecret = clientSecret; - } - - @Override - public WeaviateClient getAuthClient(Config config, List scopes) throws AuthException { - AccessTokenProvider tokenProvider = nimbusAuth.getAccessTokenProvider(config, clientSecret, "", "", scopes, AuthType.CLIENT_CREDENTIALS); - return new WeaviateClient(config, tokenProvider); - } - - @Override - public WeaviateClient getAuthClient(Config config) throws AuthException { - return getAuthClient(config, null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/ResourceOwnerPasswordFlow.java b/src/main/java/io/weaviate/client/v1/auth/ResourceOwnerPasswordFlow.java deleted file mode 100644 index 158395993..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/ResourceOwnerPasswordFlow.java +++ /dev/null @@ -1,43 +0,0 @@ -package io.weaviate.client.v1.auth; - -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.nimbus.AuthType; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import java.util.ArrayList; -import java.util.List; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; - -public class ResourceOwnerPasswordFlow implements Authentication { - - private final NimbusAuth nimbusAuth; - private final String username; - private final String password; - - public ResourceOwnerPasswordFlow(String username, String password) { - this.nimbusAuth = new NimbusAuth(); - this.username = username; - this.password = password; - } - - @Override - public WeaviateClient getAuthClient(Config config, List scopes) throws AuthException { - AccessTokenProvider tokenProvider = nimbusAuth.getAccessTokenProvider(config, "", username, password, addDefaultScopes(scopes), AuthType.USER_PASSWORD); - return new WeaviateClient(config, tokenProvider); - } - - @Override - public WeaviateClient getAuthClient(Config config) throws AuthException { - return getAuthClient(config, null); - } - - private List addDefaultScopes(List scopes) { - List withDefaultScopes = new ArrayList<>(); - withDefaultScopes.add("offline_access"); - if (scopes != null) { - scopes.forEach(withDefaultScopes::add); - } - return withDefaultScopes; - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/exception/AuthException.java b/src/main/java/io/weaviate/client/v1/auth/exception/AuthException.java deleted file mode 100644 index ceb604d8b..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/exception/AuthException.java +++ /dev/null @@ -1,15 +0,0 @@ -package io.weaviate.client.v1.auth.exception; - -public class AuthException extends Exception { - public AuthException(String message) { - super(message); - } - - public AuthException(Throwable cause) { - super(cause); - } - - public AuthException(String message, Throwable cause) { - super(message, cause); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/nimbus/AuthType.java b/src/main/java/io/weaviate/client/v1/auth/nimbus/AuthType.java deleted file mode 100644 index d7aebb96d..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/nimbus/AuthType.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.client.v1.auth.nimbus; - -public enum AuthType { - USER_PASSWORD, - CLIENT_CREDENTIALS, - REFRESH_TOKEN -} diff --git a/src/main/java/io/weaviate/client/v1/auth/nimbus/BaseAuth.java b/src/main/java/io/weaviate/client/v1/auth/nimbus/BaseAuth.java deleted file mode 100644 index aea3b3532..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/nimbus/BaseAuth.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.auth.nimbus; - -import io.weaviate.client.base.http.builder.HttpApacheClientBuilder; -import io.weaviate.client.base.http.impl.CommonsHttpClientImpl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import io.weaviate.client.Config; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.http.HttpResponse; -import io.weaviate.client.v1.auth.exception.AuthException; - -public class BaseAuth { - public final static String OIDC_URL = "/.well-known/openid-configuration"; - private final Serializer serializer; - - BaseAuth() { - this.serializer = new Serializer(); - } - - @Getter - @AllArgsConstructor - public class AuthResponse { - String clientId; - String[] scopes; - String configuration; - } - - @Getter - private class OIDCConfig { - String clientId; - String href; - String[] scopes; - } - - public AuthResponse getIdAndTokenEndpoint(Config config) throws AuthException { - HttpClient client = new CommonsHttpClientImpl(config.getHeaders(), HttpApacheClientBuilder.build(config)); - String url = config.getBaseURL() + OIDC_URL; - HttpResponse response = sendGetRequest(client, url); - switch (response.getStatusCode()) { - case 404: - String msg = "Auth001: The client was configured to use authentication, but weaviate is configured without authentication. Are you sure this is " + - "correct?"; - log(msg); - throw new AuthException(msg); - case 200: - OIDCConfig oidcConfig = serializer.toResponse(response.getBody(), OIDCConfig.class); - HttpResponse resp = sendGetRequest(client, oidcConfig.getHref()); - if (resp.getStatusCode() != 200) { - String errorMessage = String.format("OIDC configuration url %s returned status code %s", oidcConfig.getHref(), resp.getStatusCode()); - throw new AuthException(errorMessage); - } - return new AuthResponse(oidcConfig.getClientId(), oidcConfig.getScopes(), resp.getBody()); - default: - String errorMessage = String.format("OIDC configuration url %s returned status code %s", url, response.getStatusCode()); - throw new AuthException(errorMessage); - } - } - - private HttpResponse sendGetRequest(HttpClient client, String url) throws AuthException { - try { - return client.sendGetRequest(url); - } catch (Exception e) { - throw new AuthException(e); - } - } - - private void log(String msg) { - System.out.println(msg); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/nimbus/NimbusAuth.java b/src/main/java/io/weaviate/client/v1/auth/nimbus/NimbusAuth.java deleted file mode 100644 index 327865c3e..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/nimbus/NimbusAuth.java +++ /dev/null @@ -1,168 +0,0 @@ -package io.weaviate.client.v1.auth.nimbus; - -import com.nimbusds.oauth2.sdk.AuthorizationGrant; -import com.nimbusds.oauth2.sdk.ClientCredentialsGrant; -import com.nimbusds.oauth2.sdk.ErrorObject; -import com.nimbusds.oauth2.sdk.RefreshTokenGrant; -import com.nimbusds.oauth2.sdk.ResourceOwnerPasswordCredentialsGrant; -import com.nimbusds.oauth2.sdk.Scope; -import com.nimbusds.oauth2.sdk.TokenErrorResponse; -import com.nimbusds.oauth2.sdk.TokenRequest; -import com.nimbusds.oauth2.sdk.TokenResponse; -import com.nimbusds.oauth2.sdk.auth.ClientSecretPost; -import com.nimbusds.oauth2.sdk.auth.Secret; -import com.nimbusds.oauth2.sdk.http.HTTPResponse; -import com.nimbusds.oauth2.sdk.id.ClientID; -import com.nimbusds.oauth2.sdk.token.AccessToken; -import com.nimbusds.oauth2.sdk.token.RefreshToken; -import com.nimbusds.openid.connect.sdk.OIDCTokenResponse; -import com.nimbusds.openid.connect.sdk.OIDCTokenResponseParser; -import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; -import io.weaviate.client.v1.auth.provider.AuthClientCredentialsTokenProvider; -import io.weaviate.client.v1.auth.provider.AuthRefreshTokenProvider; -import java.text.SimpleDateFormat; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class NimbusAuth extends BaseAuth { - - public NimbusAuth() { - super(); - } - - public AccessTokenProvider getAccessTokenProvider(Config config, - String clientSecret, String username, String password, List clientScopes, - AuthType authType) throws AuthException { - BaseAuth.AuthResponse authResponse = getIdAndTokenEndpoint(config); - OIDCTokenResponse oidcTokenResponse = getOIDCTokenResponse(config, authResponse, - clientSecret, username, password, "", clientScopes, authType); - AccessToken accessToken = oidcTokenResponse.getOIDCTokens().getAccessToken(); - RefreshToken refreshToken = oidcTokenResponse.getOIDCTokens().getRefreshToken(); - - String refreshTokenValue = null; - if (refreshToken != null) { - refreshTokenValue = refreshToken.getValue(); - } else { - logNoRefreshTokenWarning(accessToken.getLifetime()); - } - - return getTokenProvider(config, authResponse, clientScopes, - accessToken.getValue(), accessToken.getLifetime(), refreshTokenValue, clientSecret, authType); - } - - protected AccessTokenProvider getTokenProvider(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, - String accessToken, long accessTokenLifeTime, String refreshToken, String clientSecret, AuthType authType) { - if (authType == AuthType.CLIENT_CREDENTIALS) { - return new AuthClientCredentialsTokenProvider(config, authResponse, clientScopes, accessToken, accessTokenLifeTime, clientSecret); - } - return new AuthRefreshTokenProvider(config, authResponse, accessToken, accessTokenLifeTime, refreshToken); - } - - public String refreshToken(Config config, BaseAuth.AuthResponse authResponse, String refreshToken) { - try { - OIDCTokenResponse oidcTokenResponse = getOIDCTokenResponse(config, authResponse, - "", "", "", refreshToken, null, AuthType.REFRESH_TOKEN); - return oidcTokenResponse.getOIDCTokens().getAccessToken().getValue(); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public String refreshClientCredentialsToken(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, String clientSecret) { - try { - OIDCTokenResponse oidcTokenResponse = getOIDCTokenResponse(config, authResponse, - clientSecret, "", "", "", clientScopes, AuthType.CLIENT_CREDENTIALS); - return oidcTokenResponse.getOIDCTokens().getAccessToken().getValue(); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public void logNoRefreshTokenWarning(long accessTokenLifetime) { - String msgFormat = "Auth002: Your access token is valid for %s and no refresh token was provided."; - log(String.format(msgFormat, getAccessTokenExpireDate(accessTokenLifetime))); - } - - private OIDCTokenResponse getOIDCTokenResponse(Config config, BaseAuth.AuthResponse authResponse, - String clientSecret, String username, String password, String refreshToken, List clientScopes, - AuthType authType) throws AuthException { - try { - OIDCProviderMetadata providerMetadata = OIDCProviderMetadata.parse(authResponse.getConfiguration()); - ClientID clientID = new ClientID(authResponse.getClientId()); - Secret secret = new Secret(clientSecret); - String redirectURL = String.format("%s%s", config.getBaseURL(), BaseAuth.OIDC_URL); - String responseTypes = "code id_token"; - String responseMode = "fragment"; - Scope scopes = getScopes(authResponse, clientScopes, clientID, providerMetadata); - Map> customParams = new HashMap<>(); - customParams.put("response_type", Collections.singletonList(responseTypes)); - customParams.put("response_mode", Collections.singletonList(responseMode)); - customParams.put("redirect_url", Collections.singletonList(redirectURL)); - - TokenRequest tokenReq = new TokenRequest(providerMetadata.getTokenEndpointURI(), - new ClientSecretPost(clientID, secret), - getAuthorizationGrant(authType, username, password, refreshToken), - scopes, null, customParams); - - HTTPResponse tokenHTTPResp = tokenReq.toHTTPRequest().send(); - TokenResponse tokenResponse = OIDCTokenResponseParser.parse(tokenHTTPResp); - - if (tokenResponse instanceof TokenErrorResponse) { - ErrorObject error = ((TokenErrorResponse) tokenResponse).getErrorObject(); - throw new RuntimeException(error.getDescription()); - } - - OIDCTokenResponse oidcTokenResponse = (OIDCTokenResponse) tokenResponse; - return oidcTokenResponse; - } catch (Throwable e) { - throw new AuthException(e.getMessage(), e); - } - } - - private Scope getScopes(BaseAuth.AuthResponse authResponse, List clientScopes, ClientID clientID, OIDCProviderMetadata providerMetadata) { - Scope scopes = new Scope(); - if (authResponse.getScopes() != null) { - Arrays.stream(authResponse.getScopes()).forEach(scopes::add); - } - if (clientScopes != null) { - clientScopes.forEach(scopes::add); - } - if (scopes.isEmpty()) { - if (providerMetadata.getTokenEndpointURI().getHost().equals("login.microsoftonline.com")) { - scopes.add(clientID + "/.default"); - } - } - return scopes; - } - - private AuthorizationGrant getAuthorizationGrant(AuthType authType, String username, String password, String refreshToken) { - switch (authType) { - case USER_PASSWORD: - return new ResourceOwnerPasswordCredentialsGrant(username, new Secret(password)); - case CLIENT_CREDENTIALS: - return new ClientCredentialsGrant(); - default: - return new RefreshTokenGrant(new RefreshToken(refreshToken)); - } - } - - - - private String getAccessTokenExpireDate(Long accessTokenLifetime) { - SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); - Calendar cal = Calendar.getInstance(); - cal.add(Calendar.SECOND, accessTokenLifetime.intValue()); - return dateFormat.format(cal.getTime()); - } - - private void log(String msg) { - System.out.println(msg); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/provider/AccessTokenProvider.java b/src/main/java/io/weaviate/client/v1/auth/provider/AccessTokenProvider.java deleted file mode 100644 index cd2c247b2..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/provider/AccessTokenProvider.java +++ /dev/null @@ -1,6 +0,0 @@ -package io.weaviate.client.v1.auth.provider; - -public interface AccessTokenProvider { - String getAccessToken(); - default void shutdown(){} -} diff --git a/src/main/java/io/weaviate/client/v1/auth/provider/AuthClientCredentialsTokenProvider.java b/src/main/java/io/weaviate/client/v1/auth/provider/AuthClientCredentialsTokenProvider.java deleted file mode 100644 index 01d548ed3..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/provider/AuthClientCredentialsTokenProvider.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.v1.auth.provider; - -import java.util.List; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.nimbus.BaseAuth; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; - -public class AuthClientCredentialsTokenProvider implements AccessTokenProvider { - - private final NimbusAuth nimbusAuth; - private String accessToken; - private ScheduledExecutorService executor; - - public AuthClientCredentialsTokenProvider(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, - String accessToken, long lifetimeSeconds, String clientSecret) { - this.nimbusAuth = new NimbusAuth(); - this.accessToken = accessToken; - scheduleRefreshTokenTask(config, authResponse, clientScopes, clientSecret, lifetimeSeconds); - } - - @Override - public String getAccessToken() { - return accessToken; - } - - public void shutdown() { - executor.shutdown(); - } - - private void scheduleRefreshTokenTask(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, String clientSecret, long period) { - executor = Executors.newSingleThreadScheduledExecutor(); - executor.scheduleAtFixedRate(() -> accessToken = nimbusAuth.refreshClientCredentialsToken(config, authResponse, clientScopes, clientSecret), - period, period, TimeUnit.SECONDS); - } -} diff --git a/src/main/java/io/weaviate/client/v1/auth/provider/AuthRefreshTokenProvider.java b/src/main/java/io/weaviate/client/v1/auth/provider/AuthRefreshTokenProvider.java deleted file mode 100644 index c6bee26a8..000000000 --- a/src/main/java/io/weaviate/client/v1/auth/provider/AuthRefreshTokenProvider.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.auth.provider; - -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.nimbus.BaseAuth; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; - -public class AuthRefreshTokenProvider implements AccessTokenProvider { - private final NimbusAuth nimbusAuth; - private String accessToken; - private ScheduledExecutorService executor; - - public AuthRefreshTokenProvider(Config config, BaseAuth.AuthResponse authResponse, String accessToken, long lifetimeSeconds, String refreshToken) { - this.nimbusAuth = new NimbusAuth(); - this.accessToken = accessToken; - if (StringUtils.isNotBlank(refreshToken)) { - scheduleRefreshTokenTask(config, authResponse, refreshToken, lifetimeSeconds); - } - } - - @Override - public String getAccessToken() { - return accessToken; - } - - @Override - public void shutdown() { - executor.shutdown(); - } - - private void scheduleRefreshTokenTask(Config config, BaseAuth.AuthResponse authResponse, String refreshToken, long period) { - executor = Executors.newSingleThreadScheduledExecutor(); - executor.scheduleAtFixedRate(() -> accessToken = nimbusAuth.refreshToken(config, authResponse, refreshToken), - period, period, TimeUnit.SECONDS); - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/Backup.java b/src/main/java/io/weaviate/client/v1/backup/Backup.java deleted file mode 100644 index e4b3a392f..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/Backup.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.backup; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.backup.api.*; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Backup { - - private final HttpClient httpClient; - private final Config config; - - public BackupCreator creator() { - return new BackupCreator(httpClient, config, createStatusGetter()); - } - - public BackupCreateStatusGetter createStatusGetter() { - return new BackupCreateStatusGetter(httpClient, config); - } - - public BackupRestorer restorer() { - return new BackupRestorer(httpClient, config, restoreStatusGetter()); - } - - public BackupRestoreStatusGetter restoreStatusGetter() { - return new BackupRestoreStatusGetter(httpClient, config); - } - - public BackupCanceler canceler() { - return new BackupCanceler(httpClient, config); - } - - public BackupGetter getter() { - return new BackupGetter(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupCanceler.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupCanceler.java deleted file mode 100644 index ac557566a..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupCanceler.java +++ /dev/null @@ -1,73 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import java.util.ArrayList; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; - -/** - * BackupCanceler can cancel an in-progress backup by ID. - * - *

- * Canceling backups which have successfully completed before being interrupted - * is not supported and will result in an error. - */ -public class BackupCanceler extends BaseClient implements ClientResult { - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - public BackupCanceler(HttpClient client, Config config) { - super(client, config); - } - - public BackupCanceler withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCanceler withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupCanceler withPath(String path) { - this.backupPath = path; - return this; - } - - public BackupCanceler withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - @Override - public Result run() { - Response result = sendDeleteRequest(path(), null, Void.class); - return new Result<>(result); - } - - private String path() { - String path = String.format("/backups/%s/%s", backend, backupId); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return path; - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupCreateStatusGetter.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupCreateStatusGetter.java deleted file mode 100644 index b8d59dd83..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupCreateStatusGetter.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import java.util.ArrayList; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; - -public class BackupCreateStatusGetter extends BaseClient implements ClientResult { - - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - public BackupCreateStatusGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public BackupCreateStatusGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCreateStatusGetter withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupCreateStatusGetter withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupCreateStatusGetter withPath(String path) { - this.backupPath = path; - return this; - } - - @Override - public Result run() { - return new Result<>(statusCreate()); - } - - Response statusCreate() { - return sendGetRequest(path(), BackupCreateStatusResponse.class); - } - - private String path() { - String path = String.format("/backups/%s/%s", backend, backupId); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return path; - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupCreator.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupCreator.java deleted file mode 100644 index 61fe9f4df..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupCreator.java +++ /dev/null @@ -1,164 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import com.google.gson.annotations.SerializedName; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; -import io.weaviate.client.v1.backup.model.CreateStatus; -import lombok.Builder; -import lombok.Getter; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class BackupCreator extends BaseClient implements ClientResult { - - private static final long WAIT_INTERVAL = 1000; - - private final BackupCreateStatusGetter statusGetter; - private String[] includeClassNames; - private String[] excludeClassNames; - private String backend; - private String backupId; - private BackupCreateConfig config; - private boolean waitForCompletion; - - public BackupCreator(HttpClient httpClient, Config config, BackupCreateStatusGetter statusGetter) { - super(httpClient, config); - this.statusGetter = statusGetter; - } - - - public BackupCreator withIncludeClassNames(String... classNames) { - this.includeClassNames = classNames; - return this; - } - - public BackupCreator withExcludeClassNames(String... classNames) { - this.excludeClassNames = classNames; - return this; - } - - public BackupCreator withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupCreator withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupCreator withConfig(BackupCreateConfig config) { - this.config = config; - return this; - } - - public BackupCreator withWaitForCompletion(boolean waitForCompletion) { - this.waitForCompletion = waitForCompletion; - return this; - } - - @Override - public Result run() { - BackupCreate payload = BackupCreate.builder() - .id(backupId) - .config(config) - .include(includeClassNames) - .exclude(excludeClassNames) - .build(); - - if (waitForCompletion) { - return createAndWaitForCompletion(payload); - } - return create(payload); - } - - private Result create(BackupCreate payload) { - Response response = sendPostRequest(path(), payload, BackupCreateResponse.class); - return new Result<>(response); - } - - private Result createAndWaitForCompletion(BackupCreate payload) { - Result result = create(payload); - if (result.hasErrors()) { - return result; - } - - statusGetter.withBackend(backend).withBackupId(backupId); - while(true) { - Response statusResponse = statusGetter.statusCreate(); - if (new Result<>(statusResponse).hasErrors()) { - return merge(statusResponse, result); - } - - switch (statusResponse.getBody().getStatus()) { - case CreateStatus.SUCCESS: - case CreateStatus.FAILED: - return merge(statusResponse, result); - } - - try { - Thread.sleep(WAIT_INTERVAL); - } catch (InterruptedException e) { - return merge(statusResponse, result); - } - } - } - - private String path() { - return String.format("/backups/%s", backend); - } - - private Result merge(Response response, Result result) { - BackupCreateStatusResponse statusCreateResponse = response.getBody(); - BackupCreateResponse createResponse = result.getResult(); - - BackupCreateResponse merged = null; - if (statusCreateResponse != null) { - merged = new BackupCreateResponse(); - - merged.setId(statusCreateResponse.getId()); - merged.setBackend(statusCreateResponse.getBackend()); - merged.setPath(statusCreateResponse.getPath()); - merged.setStatus(statusCreateResponse.getStatus()); - merged.setError(statusCreateResponse.getError()); - merged.setClassNames(createResponse.getClassNames()); - } - - return new Result<>(response.getStatusCode(), merged, response.getErrors()); - } - - - @Getter - @Builder - private static class BackupCreate { - String id; - String[] include; - String[] exclude; - BackupCreateConfig config; - } - - @Getter - @Builder - public static class BackupCreateConfig { - @SerializedName("CPUPercentage") - Integer cpuPercentage; - @SerializedName("ChunkSize") - Integer chunkSize; - @SerializedName("CompressionLevel") - String compressionLevel; - @SerializedName("Bucket") - String bucket; - @SerializedName("Path") - String path; - } - - public interface BackupCompression { - String DEFAULT_COMPRESSION = "DefaultCompression"; - String BEST_SPEED = "BestSpeed"; - String BEST_COMPRESSION = "BestCompression"; - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupGetter.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupGetter.java deleted file mode 100644 index 1ffe390d7..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupGetter.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class BackupGetter extends BaseClient implements ClientResult { - - private String backend; - - public BackupGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public BackupGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - @Override - public Result run() { - Response response = this.sendGetRequest(path(), BackupCreateResponse[].class); - return new Result<>(response); - } - - private String path() { - return String.format("/backups/%s", backend); - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupRestoreStatusGetter.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupRestoreStatusGetter.java deleted file mode 100644 index 3807d4a43..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupRestoreStatusGetter.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import java.util.ArrayList; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; - -public class BackupRestoreStatusGetter extends BaseClient implements ClientResult { - - private String backend; - private String backupId; - private String bucket; - private String backupPath; - - public BackupRestoreStatusGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public BackupRestoreStatusGetter withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupRestoreStatusGetter withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupRestoreStatusGetter withBucket(String bucket) { - this.bucket = bucket; - return this; - } - - public BackupRestoreStatusGetter withPath(String path) { - this.backupPath = path; - return this; - } - - @Override - public Result run() { - return new Result<>(statusRestore()); - } - - Response statusRestore() { - return sendGetRequest(path(), BackupRestoreStatusResponse.class); - } - - private String path() { - String path = String.format("/backups/%s/%s/restore", backend, backupId); - - List queryParams = new ArrayList<>(); - if (this.bucket != null) { - queryParams.add(UrlEncoder.encodeQueryParam("bucket", this.bucket)); - } - if (this.backupPath != null) { - queryParams.add(UrlEncoder.encodeQueryParam("path", this.backupPath)); - } - - if (!queryParams.isEmpty()) { - path += "?" + String.join("&", queryParams); - } - return path; - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/api/BackupRestorer.java b/src/main/java/io/weaviate/client/v1/backup/api/BackupRestorer.java deleted file mode 100644 index 7f17bdb29..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/api/BackupRestorer.java +++ /dev/null @@ -1,174 +0,0 @@ -package io.weaviate.client.v1.backup.api; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.backup.model.BackupRestoreResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; -import io.weaviate.client.v1.backup.model.RbacRestoreOption; -import io.weaviate.client.v1.backup.model.RestoreStatus; -import lombok.Builder; -import lombok.Getter; - -public class BackupRestorer extends BaseClient implements ClientResult { - - private static final long WAIT_INTERVAL = 1000; - - private final BackupRestoreStatusGetter statusGetter; - private String[] includeClassNames; - private String[] excludeClassNames; - private String backend; - private String backupId; - private Boolean overwriteAlias; - private BackupRestoreConfig config; - private boolean waitForCompletion; - - public BackupRestorer(HttpClient httpClient, Config config, BackupRestoreStatusGetter statusGetter) { - super(httpClient, config); - this.statusGetter = statusGetter; - } - - public BackupRestorer withIncludeClassNames(String... classNames) { - this.includeClassNames = classNames; - return this; - } - - public BackupRestorer withExcludeClassNames(String... classNames) { - this.excludeClassNames = classNames; - return this; - } - - public BackupRestorer withBackend(String backend) { - this.backend = backend; - return this; - } - - public BackupRestorer withOverwriteAlias(Boolean overwriteAlias) { - this.overwriteAlias = overwriteAlias; - return this; - } - - public BackupRestorer withConfig(BackupRestoreConfig config) { - this.config = config; - return this; - } - - @Deprecated - public BackupRestorer backend(String backend) { - return withBackend(backend); - } - - public BackupRestorer withBackupId(String backupId) { - this.backupId = backupId; - return this; - } - - public BackupRestorer withWaitForCompletion(boolean waitForCompletion) { - this.waitForCompletion = waitForCompletion; - return this; - } - - @Override - public Result run() { - BackupRestore payload = BackupRestore.builder() - .include(includeClassNames) - .exclude(excludeClassNames) - .overwriteAlias(overwriteAlias) - .config(config) - .build(); - - if (waitForCompletion) { - return restoreAndWaitForCompletion(payload); - } - return restore(payload); - } - - private Result restore(BackupRestore payload) { - Response response = sendPostRequest(path(), payload, BackupRestoreResponse.class); - return new Result<>(response); - } - - private Result restoreAndWaitForCompletion(BackupRestore payload) { - Result result = restore(payload); - if (result.hasErrors()) { - return result; - } - - statusGetter.withBackend(backend).withBackupId(backupId); - while (true) { - Response statusResponse = statusGetter.statusRestore(); - if (new Result<>(statusResponse).hasErrors()) { - return merge(statusResponse, result); - } - - switch (statusResponse.getBody().getStatus()) { - case RestoreStatus.SUCCESS: - case RestoreStatus.FAILED: - return merge(statusResponse, result); - } - - try { - Thread.sleep(WAIT_INTERVAL); - } catch (InterruptedException e) { - return merge(statusResponse, result); - } - } - } - - private String path() { - return String.format("/backups/%s/%s/restore", backend, backupId); - } - - private Result merge(Response response, - Result result) { - BackupRestoreStatusResponse statusRestoreResponse = response.getBody(); - BackupRestoreResponse restoreResponse = result.getResult(); - - BackupRestoreResponse merged = null; - if (statusRestoreResponse != null) { - merged = new BackupRestoreResponse(); - - merged.setId(statusRestoreResponse.getId()); - merged.setBackend(statusRestoreResponse.getBackend()); - merged.setPath(statusRestoreResponse.getPath()); - merged.setStatus(statusRestoreResponse.getStatus()); - merged.setError(statusRestoreResponse.getError()); - merged.setClassNames(restoreResponse.getClassNames()); - } - - return new Result<>(response.getStatusCode(), merged, response.getErrors()); - } - - @Getter - @Builder - private static class BackupRestore { - @SerializedName("config") - BackupRestoreConfig config; - @SerializedName("include") - String[] include; - @SerializedName("exclude") - String[] exclude; - @SerializedName("overwriteAlias") - Boolean overwriteAlias; - } - - @Getter - @Builder - public static class BackupRestoreConfig { - @SerializedName("CPUPercentage") - Integer cpuPercentage; - @SerializedName("Bucket") - String bucket; - @SerializedName("Path") - String path; - @SerializedName("usersOptions") - RbacRestoreOption usersRestore; - @SerializedName("rolesOptions") - RbacRestoreOption rolesRestore; - } -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/Backend.java b/src/main/java/io/weaviate/client/v1/backup/model/Backend.java deleted file mode 100644 index 173104c62..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/Backend.java +++ /dev/null @@ -1,9 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -public interface Backend { - - String FILESYSTEM = "filesystem"; - String S3 = "s3"; - String GCS = "gcs"; - String AZURE = "azure"; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateResponse.java b/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateResponse.java deleted file mode 100644 index a9e1c04b6..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateResponse.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BackupCreateResponse { - - String id; - String path; - String backend; - @SerializedName("classes") - String[] classNames; - String status; - String error; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateStatusResponse.java b/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateStatusResponse.java deleted file mode 100644 index 57f8b23d9..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/BackupCreateStatusResponse.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BackupCreateStatusResponse { - - String id; - String path; - String backend; - String status; - String error; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreResponse.java b/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreResponse.java deleted file mode 100644 index bfbad2a8f..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreResponse.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BackupRestoreResponse { - - String id; - String path; - String backend; - @SerializedName("classes") - String[] classNames; - String status; - String error; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreStatusResponse.java b/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreStatusResponse.java deleted file mode 100644 index 905d0a3d7..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/BackupRestoreStatusResponse.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BackupRestoreStatusResponse { - - String id; - String path; - String backend; - String status; - String error; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/CreateStatus.java b/src/main/java/io/weaviate/client/v1/backup/model/CreateStatus.java deleted file mode 100644 index 71b61f5a3..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/CreateStatus.java +++ /dev/null @@ -1,11 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -public interface CreateStatus { - - String STARTED = "STARTED"; - String TRANSFERRING = "TRANSFERRING"; - String TRANSFERRED = "TRANSFERRED"; - String SUCCESS = "SUCCESS"; - String FAILED = "FAILED"; - String CANCELED = "CANCELED"; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/RbacRestoreOption.java b/src/main/java/io/weaviate/client/v1/backup/model/RbacRestoreOption.java deleted file mode 100644 index 30ea9b2bb..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/RbacRestoreOption.java +++ /dev/null @@ -1,10 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -import com.google.gson.annotations.SerializedName; - -public enum RbacRestoreOption { - @SerializedName("noRestore") - NO_RESTORE, - @SerializedName("all") - ALL; -} diff --git a/src/main/java/io/weaviate/client/v1/backup/model/RestoreStatus.java b/src/main/java/io/weaviate/client/v1/backup/model/RestoreStatus.java deleted file mode 100644 index c1957e1b1..000000000 --- a/src/main/java/io/weaviate/client/v1/backup/model/RestoreStatus.java +++ /dev/null @@ -1,10 +0,0 @@ -package io.weaviate.client.v1.backup.model; - -public interface RestoreStatus { - - String STARTED = "STARTED"; - String TRANSFERRING = "TRANSFERRING"; - String TRANSFERRED = "TRANSFERRED"; - String SUCCESS = "SUCCESS"; - String FAILED = "FAILED"; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/Batch.java b/src/main/java/io/weaviate/client/v1/batch/Batch.java deleted file mode 100644 index 5675f26d9..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/Batch.java +++ /dev/null @@ -1,113 +0,0 @@ -package io.weaviate.client.v1.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.api.ObjectsBatchDeleter; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.api.ReferencePayloadBuilder; -import io.weaviate.client.v1.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import io.weaviate.client.v1.batch.util.ReferencesPath; -import io.weaviate.client.v1.data.Data; - -public class Batch { - private final Config config; - private final HttpClient httpClient; - private final AccessTokenProvider tokenProvider; - private final BeaconPath beaconPath; - private final ObjectsPath objectsPath; - private final ReferencesPath referencesPath; - private final GrpcVersionSupport grpcVersionSupport; - private final Data data; - - public Batch(HttpClient httpClient, Config config, DbVersionSupport dbVersionSupport, GrpcVersionSupport grpcVersionSupport, - AccessTokenProvider tokenProvider, Data data) { - this.config = config; - this.httpClient = httpClient; - this.tokenProvider = tokenProvider; - this.beaconPath = new BeaconPath(dbVersionSupport); - this.grpcVersionSupport = grpcVersionSupport; - this.objectsPath = new ObjectsPath(); - this.referencesPath = new ReferencesPath(); - this.data = data; - } - - public ObjectsBatcher objectsBatcher() { - return objectsBatcher(ObjectsBatcher.BatchRetriesConfig.defaultConfig().build()); - } - - public ObjectsBatcher objectsBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig) { - return ObjectsBatcher.create(httpClient, config, data, objectsPath, tokenProvider, grpcVersionSupport, batchRetriesConfig); - } - - public ObjectsBatcher objectsAutoBatcher() { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - ObjectsBatcher.AutoBatchConfig.defaultConfig().build() - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig) { - return objectsAutoBatcher( - batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig.defaultConfig().build() - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.AutoBatchConfig autoBatchConfig) { - return objectsAutoBatcher( - ObjectsBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig - ); - } - - public ObjectsBatcher objectsAutoBatcher(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - ObjectsBatcher.AutoBatchConfig autoBatchConfig) { - return ObjectsBatcher.createAuto(httpClient, config, data, objectsPath, tokenProvider, grpcVersionSupport, batchRetriesConfig, autoBatchConfig); - } - - public ObjectsBatchDeleter objectsBatchDeleter() { - return new ObjectsBatchDeleter(httpClient, config, objectsPath); - } - - public ReferencePayloadBuilder referencePayloadBuilder() { - return new ReferencePayloadBuilder(beaconPath); - } - - public ReferencesBatcher referencesBatcher() { - return referencesBatcher(ReferencesBatcher.BatchRetriesConfig.defaultConfig().build()); - } - public ReferencesBatcher referencesBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig) { - return ReferencesBatcher.create(httpClient, config, referencesPath, batchRetriesConfig); - } - - public ReferencesBatcher referencesAutoBatcher() { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - ReferencesBatcher.AutoBatchConfig.defaultConfig().build() - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig) { - return referencesAutoBatcher( - batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig.defaultConfig().build() - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.AutoBatchConfig autoBatchConfig) { - return referencesAutoBatcher( - ReferencesBatcher.BatchRetriesConfig.defaultConfig().build(), - autoBatchConfig - ); - } - - public ReferencesBatcher referencesAutoBatcher(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - ReferencesBatcher.AutoBatchConfig autoBatchConfig) { - return ReferencesBatcher.createAuto(httpClient, config, referencesPath, batchRetriesConfig, autoBatchConfig); - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatchDeleter.java b/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatchDeleter.java deleted file mode 100644 index 01afbd982..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatchDeleter.java +++ /dev/null @@ -1,102 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import com.google.gson.annotations.SerializedName; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import lombok.Builder; -import lombok.Getter; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.filters.WhereFilter; - -public class ObjectsBatchDeleter extends BaseClient implements ClientResult { - - private final ObjectsPath objectsPath; - private String className; - private String consistencyLevel; - private String tenant; - private WhereFilter where; - private String output; - private Boolean dryRun; - - - public ObjectsBatchDeleter(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectsPath = objectsPath; - } - - - public ObjectsBatchDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsBatchDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectsBatchDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectsBatchDeleter withWhere(WhereFilter where) { - this.where = where; - return this; - } - - public ObjectsBatchDeleter withOutput(String output) { - this.output = output; - return this; - } - - public ObjectsBatchDeleter withDryRun(Boolean dryRun) { - this.dryRun = dryRun; - return this; - } - - - @Override - public Result run() { - BatchDeleteMatch match = BatchDeleteMatch.builder() - .className(className) - .whereFilter(where) - .build(); - BatchDelete batchDelete = BatchDelete.builder() - .dryRun(dryRun) - .output(output) - .match(match) - .build(); - String path = objectsPath.buildDelete(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .build()); - Response resp = sendDeleteRequest(path, batchDelete, BatchDeleteResponse.class); - return new Result<>(resp); - } - - - @Getter - @Builder - public static class BatchDelete { - - BatchDeleteMatch match; - String output; - Boolean dryRun; - } - - @Getter - @Builder - public static class BatchDeleteMatch { - - @SerializedName("class") - String className; - @SerializedName("where") - WhereFilter whereFilter; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatcher.java b/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatcher.java deleted file mode 100644 index 937f16dee..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/api/ObjectsBatcher.java +++ /dev/null @@ -1,622 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import java.io.Closeable; -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Executor; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import java.util.function.Consumer; -import java.util.function.Supplier; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.Pair; -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.grpc.GrpcClient; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.Assert; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch.BatchObjectsReply.BatchError; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.grpc.BatchObjectConverter; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsBatchRequestBody; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result.ErrorResponse; -import io.weaviate.client.v1.batch.util.ObjectsPath; -import io.weaviate.client.v1.data.Data; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -public class ObjectsBatcher extends BaseClient - implements ClientResult, Closeable { - - private final Data data; - private final ObjectsPath objectsPath; - - private final BatchRetriesConfig batchRetriesConfig; - private final AutoBatchConfig autoBatchConfig; - private final boolean autoRunEnabled; - private final ScheduledExecutorService executorService; - private final DelayedExecutor delayedExecutor; - private final List objects; - private String consistencyLevel; - private final List>> undoneFutures; - private final boolean useGRPC; - private final AccessTokenProvider tokenProvider; - private final GrpcVersionSupport grpcVersionSupport; - private final Config config; - - private ObjectsBatcher(HttpClient httpClient, Config config, Data data, ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig) { - super(httpClient, config); - this.config = config; - this.useGRPC = config.useGRPC(); - this.tokenProvider = tokenProvider; - this.data = data; - this.objectsPath = objectsPath; - this.grpcVersionSupport = grpcVersionSupport; - this.objects = new ArrayList<>(); - this.batchRetriesConfig = batchRetriesConfig; - - if (autoBatchConfig != null) { - this.autoRunEnabled = true; - this.autoBatchConfig = autoBatchConfig; - this.executorService = Executors.newScheduledThreadPool(autoBatchConfig.poolSize); - this.delayedExecutor = new ExecutorServiceDelayedExecutor(executorService); - this.undoneFutures = Collections.synchronizedList(new ArrayList<>()); - } else { - this.autoRunEnabled = false; - this.autoBatchConfig = null; - this.executorService = null; - this.delayedExecutor = new SleepDelayedExecutor(); - this.undoneFutures = null; - } - } - - public static ObjectsBatcher create(HttpClient httpClient, Config config, Data data, ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - BatchRetriesConfig batchRetriesConfig) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - return new ObjectsBatcher(httpClient, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, null); - } - - public static ObjectsBatcher createAuto(HttpClient httpClient, Config config, Data data, ObjectsPath objectsPath, - AccessTokenProvider tokenProvider, GrpcVersionSupport grpcVersionSupport, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - Assert.requiredNotNull(autoBatchConfig, "autoBatchConfig"); - return new ObjectsBatcher(httpClient, config, data, objectsPath, tokenProvider, grpcVersionSupport, - batchRetriesConfig, autoBatchConfig); - } - - public ObjectsBatcher withObject(WeaviateObject object) { - return withObjects(object); - } - - public ObjectsBatcher withObjects(WeaviateObject... objects) { - addMissingIds(objects); - this.objects.addAll(Arrays.asList(objects)); - autoRun(); - return this; - } - - public ObjectsBatcher withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - @Override - public Result run() { - if (autoRunEnabled) { - flush(); // fallback to flush in auto run enabled - return null; - } - - if (objects.isEmpty()) { - return new Result<>(0, new ObjectGetResponse[0], null); - } - - List batch = extractBatch(objects.size()); - return runRecursively(batch, 0, 0, null, - (DelayedExecutor>) delayedExecutor); - } - - public void flush() { - if (!autoRunEnabled) { - run(); // fallback to run if auto run disabled - return; - } - - if (!objects.isEmpty()) { - List batch = extractBatch(objects.size()); - runInThread(batch); - } - - CompletableFuture[] futures = undoneFutures.toArray(new CompletableFuture[0]); - if (futures.length == 0) { - return; - } - - CompletableFuture.allOf(futures).join(); - } - - @Override - public void close() { - if (!autoRunEnabled) { - return; - } - - executorService.shutdown(); - try { - if (!executorService.awaitTermination(autoBatchConfig.awaitTerminationMs, TimeUnit.MILLISECONDS)) { - executorService.shutdownNow(); - } - } catch (InterruptedException e) { - executorService.shutdownNow(); - } - } - - private void addMissingIds(WeaviateObject[] objects) { - Arrays.stream(objects) - .filter(o -> o.getId() == null) - .forEach(o -> o.setId(UUID.randomUUID().toString())); - } - - private List extractBatch(int batchSize) { - List batch = new ArrayList<>(batchSize); - List sublist = objects.subList(0, batchSize); - - batch.addAll(sublist); - sublist.clear(); - - return batch; - } - - private void autoRun() { - if (!autoRunEnabled) { - return; - } - - while (objects.size() >= autoBatchConfig.batchSize) { - List batch = extractBatch(autoBatchConfig.batchSize); - runInThread(batch); - } - } - - private void runInThread(List batch) { - CompletableFuture> future = CompletableFuture.supplyAsync( - () -> createRunFuture(batch), - executorService).thenCompose(f -> f); - - if (autoBatchConfig.callback != null) { - future = future.whenComplete((result, e) -> autoBatchConfig.callback.accept(result)); - } - - CompletableFuture> undoneFuture = future; - undoneFutures.add(undoneFuture); - undoneFuture.whenComplete((result, ex) -> undoneFutures.remove(undoneFuture)); - } - - private CompletableFuture> createRunFuture(List batch) { - return runRecursively(batch, 0, 0, null, - (DelayedExecutor>>) delayedExecutor); - } - - private T runRecursively(List batch, int connectionErrorCount, int timeoutErrorCount, - List combinedSingleResponses, DelayedExecutor delayedExecutor) { - Result result = useGRPC ? internalGrpcRun(batch) : internalRun(batch); - - if (result.hasErrors()) { - List messages = result.getError().getMessages(); - if (!messages.isEmpty()) { - Throwable throwable = messages.get(0).getThrowable(); - boolean executeAgain = false; - int delay = 0; - - if (throwable instanceof ConnectException) { - if (connectionErrorCount++ < batchRetriesConfig.maxConnectionRetries) { - executeAgain = true; - delay = connectionErrorCount * batchRetriesConfig.retriesIntervalMs; - } - } else if (throwable instanceof SocketTimeoutException) { - Pair, List> pair = fetchCreatedAndBuildBatchToReRun(batch); - combinedSingleResponses = combineSingleResponses(combinedSingleResponses, pair.getLeft()); - batch = pair.getRight(); - - if (ObjectUtils.isNotEmpty(batch) && timeoutErrorCount++ < batchRetriesConfig.maxTimeoutRetries) { - executeAgain = true; - delay = timeoutErrorCount * batchRetriesConfig.retriesIntervalMs; - } - } - - if (executeAgain) { - int lambdaConnectionErrorCount = connectionErrorCount; - int lambdaTimeoutErrorCount = timeoutErrorCount; - List lambdaBatch = batch; - List lambdaCombinedSingleResponses = combinedSingleResponses; - - return delayedExecutor.delayed( - delay, - () -> runRecursively(lambdaBatch, lambdaConnectionErrorCount, lambdaTimeoutErrorCount, - lambdaCombinedSingleResponses, delayedExecutor)); - } - } - } else { - batch = null; - } - - Result finalResult = createFinalResultFromLastResultAndCombinedSingleResponses(result, - combinedSingleResponses, batch); - return delayedExecutor.now(finalResult); - } - - private Result internalRun(List batch) { - ObjectsBatchRequestBody batchRequest = ObjectsBatchRequestBody.builder() - .objects(batch.toArray(new WeaviateObject[batch.size()])) - .fields(new String[] { "ALL" }) - .build(); - String path = objectsPath.buildCreate(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - Response resp = sendPostRequest(path, batchRequest, ObjectGetResponse[].class); - return new Result<>(resp); - } - - private Result internalGrpcRun(List batch) { - BatchObjectConverter batchObjectConverter = new BatchObjectConverter(grpcVersionSupport); - List batchObjects = batch.stream() - .map(batchObjectConverter::toBatchObject) - .collect(Collectors.toList()); - WeaviateProtoBatch.BatchObjectsRequest.Builder batchObjectsRequestBuilder = WeaviateProtoBatch.BatchObjectsRequest - .newBuilder(); - batchObjectsRequestBuilder.addAllObjects(batchObjects); - if (consistencyLevel != null) { - WeaviateProtoBase.ConsistencyLevel cl = WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE; - if (consistencyLevel.equals(ConsistencyLevel.ALL)) { - cl = WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ALL; - } - if (consistencyLevel.equals(ConsistencyLevel.QUORUM)) { - cl = WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_QUORUM; - } - batchObjectsRequestBuilder.setConsistencyLevel(cl); - } - - WeaviateProtoBatch.BatchObjectsRequest batchObjectsRequest = batchObjectsRequestBuilder.build(); - WeaviateProtoBatch.BatchObjectsReply batchObjectsReply; - GrpcClient grpcClient = GrpcClient.create(this.config, this.tokenProvider); - try { - batchObjectsReply = grpcClient.batchObjects(batchObjectsRequest); - } finally { - grpcClient.shutdown(); - } - return resultFromBatchObjectsReply(batchObjectsReply, batch); - } - - public static Result resultFromBatchObjectsReply(BatchObjectsReply reply, - List batch) { - Map errors = reply.getErrorsList() - .stream().collect(Collectors.toMap(BatchError::getIndex, BatchError::getError)); - List errorMessages = new ArrayList<>(); - WeaviateErrorResponse responseError = null; - int responseCode = HttpStatus.SC_SUCCESS; - - ObjectGetResponse[] responseObjects = new ObjectGetResponse[batch.size()]; - for (int i = 0; i < responseObjects.length; i++) { - ObjectGetResponse r = new ObjectGetResponse(); - ObjectsGetResponseAO2Result insertResult = new ObjectsGetResponseAO2Result(); - if (errors.containsKey(i)) { - insertResult.setStatus(ObjectGetResponseStatus.FAILED); - insertResult.setErrors(new ErrorResponse(errors.get(i))); - - errorMessages.add(WeaviateErrorMessage.builder().message(errors.get(i)).build()); - } else { - insertResult.setStatus(ObjectGetResponseStatus.SUCCESS); - - WeaviateObject batchObject = batch.get(i); - r.setId(batchObject.getId()); - r.setClassName(batchObject.getClassName()); - r.setTenant(batchObject.getTenant()); - r.setVector(batchObject.getVector()); - r.setVectors(batchObject.getVectors()); - r.setMultiVectors(batchObject.getMultiVectors()); - } - r.setResult(insertResult); - responseObjects[i] = r; - } - - if (!errors.isEmpty()) { - responseCode = HttpStatus.SC_UNPROCESSABLE_CONTENT; - - // An important distinction between internalGrpcRun and internalRun - // is that the regular batching (non-gRPC) method will not surface - // an error on the "response level" and only report errors on the - // object level. - // - // Because previously internalGrpcRun used to return 422 and a - // WeaviateErrorResponse on partial errors too, we preserve this - // behavior for b/c. - responseError = WeaviateErrorResponse.builder() - .code(responseCode) - .message(StringUtils.join(errors.values(), ",")) - .error(errorMessages).build(); - } - return new Result<>(responseCode, responseObjects, responseError); - } - - private Pair, List> fetchCreatedAndBuildBatchToReRun( - List batch) { - List rerunBatch = new ArrayList<>(batch.size()); - List createdResponses = new ArrayList<>(batch.size()); - - for (WeaviateObject batchObject : batch) { - Result> existingResult = fetchExistingObject(batchObject); - - if (existingResult.hasErrors() || ObjectUtils.isEmpty(existingResult.getResult())) { - rerunBatch.add(batchObject); - continue; - } - - WeaviateObject existingObject = existingResult.getResult().get(0); - if (isDifferentObject(batchObject, existingObject)) { - rerunBatch.add(batchObject); - continue; - } - - createdResponses.add(createResponseFromExistingObject(existingObject)); - } - - return Pair.of(createdResponses, rerunBatch); - } - - private Result> fetchExistingObject(WeaviateObject batchObject) { - return data.objectsGetter() - .withID(batchObject.getId()) - .withClassName(batchObject.getClassName()) - .withVector() - .run(); - } - - private boolean isDifferentObject(WeaviateObject batchObject, WeaviateObject existingObject) { - if ((existingObject.getVector() != null || batchObject.getVector() != null) - && !Arrays.equals(existingObject.getVector(), batchObject.getVector())) { - return true; - } - - Map existingProperties = existingObject.getProperties(); - Map batchProperties = batchObject.getProperties(); - - if ((existingProperties != null && batchProperties == null) - || (existingProperties == null && batchProperties != null)) { - return true; - } - - if (existingProperties != null && !existingProperties.equals(batchProperties)) { - // TODO improve as lists will always be != - return true; - } - - return false; - } - - private ObjectGetResponse createResponseFromExistingObject(WeaviateObject existingObject) { - ObjectsGetResponseAO2Result result = new ObjectsGetResponseAO2Result(); - result.setStatus(ObjectGetResponseStatus.SUCCESS); - - ObjectGetResponse response = new ObjectGetResponse(); - response.setId(existingObject.getId()); - response.setClassName(existingObject.getClassName()); - response.setProperties(existingObject.getProperties()); - response.setAdditional(existingObject.getAdditional()); - response.setCreationTimeUnix(existingObject.getCreationTimeUnix()); - response.setLastUpdateTimeUnix(existingObject.getLastUpdateTimeUnix()); - response.setVector(existingObject.getVector()); - response.setVectors(existingObject.getVectors()); - response.setMultiVectors(existingObject.getMultiVectors()); - response.setVectorWeights(existingObject.getVectorWeights()); - response.setResult(result); - - return response; - } - - private List combineSingleResponses(List combinedSingleResponses, - List createdResponses) { - if (ObjectUtils.isNotEmpty(createdResponses)) { - combinedSingleResponses = ObjectUtils.isEmpty(combinedSingleResponses) - ? createdResponses - : Stream.of(combinedSingleResponses, createdResponses) - .flatMap(Collection::stream) - .collect(Collectors.toList()); - } - - return combinedSingleResponses; - } - - private Result createFinalResultFromLastResultAndCombinedSingleResponses( - Result lastResult, List combinedSingleResponses, - List failedBatch) { - - if (ObjectUtils.isEmpty(failedBatch) && ObjectUtils.isEmpty(combinedSingleResponses)) { - return lastResult; - } - - int statusCode = 0; - ObjectGetResponse[] allResponses = null; - if (ObjectUtils.isNotEmpty(lastResult.getResult())) { - allResponses = lastResult.getResult(); - } - if (ObjectUtils.isNotEmpty(combinedSingleResponses)) { - allResponses = ArrayUtils.addAll(allResponses, combinedSingleResponses.toArray(new ObjectGetResponse[0])); - } - - if (ObjectUtils.isEmpty(failedBatch)) { - return new Result<>(statusCode, allResponses, null); - } - - String failedIds = failedBatch.stream().map(WeaviateObject::getId).collect(Collectors.joining(", ")); - WeaviateErrorMessage failedIdsMessage = WeaviateErrorMessage.builder().message("Failed ids: " + failedIds).build(); - List messages; - - if (lastResult.hasErrors()) { - statusCode = lastResult.getError().getStatusCode(); - List prevMessages = lastResult.getError().getMessages(); - messages = new ArrayList<>(prevMessages.size() + 1); - messages.addAll(prevMessages); - messages.add(failedIdsMessage); - } else { - messages = Collections.singletonList(failedIdsMessage); - } - - return new Result<>(statusCode, allResponses, WeaviateErrorResponse.builder() - .error(messages) - .code(statusCode) - .build()); - } - - private interface DelayedExecutor { - T delayed(int delay, Supplier supplier); - - T now(Result result); - } - - @RequiredArgsConstructor - private static class ExecutorServiceDelayedExecutor - implements DelayedExecutor>> { - - private final ScheduledExecutorService executorService; - - @Override - public CompletableFuture> delayed(int delay, - Supplier>> supplier) { - Executor executor = (runnable) -> executorService.schedule(runnable, delay, TimeUnit.MILLISECONDS); - return CompletableFuture.supplyAsync(supplier, executor).thenCompose(f -> f); - } - - @Override - public CompletableFuture> now(Result result) { - return CompletableFuture.completedFuture(result); - } - } - - private static class SleepDelayedExecutor implements DelayedExecutor> { - - @Override - public Result delayed(int delay, Supplier> supplier) { - try { - Thread.sleep(delay); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - } - return supplier.get(); - } - - @Override - public Result now(Result result) { - return result; - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class BatchRetriesConfig { - - public static final int MAX_TIMEOUT_RETRIES = 3; - public static final int MAX_CONNECTION_RETRIES = 3; - public static final int RETRIES_INTERVAL = 2000; - - int maxTimeoutRetries; - int maxConnectionRetries; - int retriesIntervalMs; - - private BatchRetriesConfig(int maxTimeoutRetries, int maxConnectionRetries, int retriesIntervalMs) { - Assert.requireGreaterEqual(maxTimeoutRetries, 0, "maxTimeoutRetries"); - Assert.requireGreaterEqual(maxConnectionRetries, 0, "maxConnectionRetries"); - Assert.requireGreater(retriesIntervalMs, 0, "retriesIntervalMs"); - - this.maxTimeoutRetries = maxTimeoutRetries; - this.maxConnectionRetries = maxConnectionRetries; - this.retriesIntervalMs = retriesIntervalMs; - } - - public static BatchRetriesConfigBuilder defaultConfig() { - return BatchRetriesConfig.builder() - .maxTimeoutRetries(MAX_TIMEOUT_RETRIES) - .maxConnectionRetries(MAX_CONNECTION_RETRIES) - .retriesIntervalMs(RETRIES_INTERVAL); - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class AutoBatchConfig { - - public static final int BATCH_SIZE = 100; - public static final int POOL_SIZE = 1; - public static final int AWAIT_TERMINATION_MS = 10_000; - - int batchSize; - int poolSize; - int awaitTerminationMs; - Consumer> callback; - - private AutoBatchConfig(int batchSize, int poolSize, int awaitTerminationMs, - Consumer> callback) { - Assert.requireGreaterEqual(batchSize, 1, "batchSize"); - Assert.requireGreaterEqual(poolSize, 1, "corePoolSize"); - Assert.requireGreater(awaitTerminationMs, 0, "awaitTerminationMs"); - - this.batchSize = batchSize; - this.poolSize = poolSize; - this.awaitTerminationMs = awaitTerminationMs; - this.callback = callback; - } - - public static AutoBatchConfigBuilder defaultConfig() { - return AutoBatchConfig.builder() - .batchSize(BATCH_SIZE) - .poolSize(POOL_SIZE) - .awaitTerminationMs(AWAIT_TERMINATION_MS) - .callback(null); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilder.java b/src/main/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilder.java deleted file mode 100644 index d3b19a9b1..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilder.java +++ /dev/null @@ -1,92 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import io.weaviate.client.v1.batch.model.BatchReference; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.base.util.BeaconPath; - -import java.util.Objects; - -public class ReferencePayloadBuilder { - - private final BeaconPath beaconPath; - private String fromUUID; - private String fromClassName; - private String fromPropertyName; - private String toUUID; - private String toClassName; - private String tenant; - - @Deprecated - public ReferencePayloadBuilder() { - this.beaconPath = null; - System.err.println("WARNING: Deprecated constructor for ReferencePayloadBuilder class was used. Please use parametrized one."); - } - - public ReferencePayloadBuilder(BeaconPath beaconPath) { - this.beaconPath = Objects.requireNonNull(beaconPath); - } - - public ReferencePayloadBuilder withFromID(String uuid) { - this.fromUUID = uuid; - return this; - } - - public ReferencePayloadBuilder withFromClassName(String className) { - this.fromClassName = className; - return this; - } - - public ReferencePayloadBuilder withFromRefProp(String propertyName) { - this.fromPropertyName = propertyName; - return this; - } - - public ReferencePayloadBuilder withToID(String uuid) { - this.toUUID = uuid; - return this; - } - - public ReferencePayloadBuilder withToClassName(String className) { - this.toClassName = className; - return this; - } - - public ReferencePayloadBuilder withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public BatchReference payload() { - if (StringUtils.isBlank(fromClassName) || StringUtils.isBlank(fromUUID) || - StringUtils.isBlank(fromPropertyName) || StringUtils.isBlank(toUUID)) { - return null; - } - - String from; - String to; - if (beaconPath != null) { - from = beaconPath.buildBatchFrom(BeaconPath.Params.builder() - .id(fromUUID) - .className(fromClassName) - .property(fromPropertyName) - .build()); - to = beaconPath.buildBatchTo(BeaconPath.Params.builder() - .id(toUUID) - .className(toClassName) - .build()); - } else { - from = beaconFromDeprecated(); - to = beaconToDeprecated(); - } - - return BatchReference.builder().from(from).to(to).tenant(tenant).build(); - } - - private String beaconFromDeprecated() { - return String.format("weaviate://localhost/%s/%s/%s", fromClassName, fromUUID, fromPropertyName); - } - - private String beaconToDeprecated() { - return String.format("weaviate://localhost/%s", toUUID); - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/api/ReferencesBatcher.java b/src/main/java/io/weaviate/client/v1/batch/api/ReferencesBatcher.java deleted file mode 100644 index a562e14c5..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/api/ReferencesBatcher.java +++ /dev/null @@ -1,392 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.util.ReferencesPath; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ObjectUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.Assert; - -import java.io.Closeable; -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Executor; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import java.util.function.Consumer; -import java.util.function.Supplier; -import java.util.stream.Collectors; - -public class ReferencesBatcher extends BaseClient - implements ClientResult, Closeable { - - private final ReferencesPath referencesPath; - - private final BatchRetriesConfig batchRetriesConfig; - private final AutoBatchConfig autoBatchConfig; - private final boolean autoRunEnabled; - private final ScheduledExecutorService executorService; - private final DelayedExecutor delayedExecutor; - private final List references; - private String consistencyLevel; - private final List>> undoneFutures; - - - private ReferencesBatcher(HttpClient httpClient, Config config, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig) { - super(httpClient, config); - this.referencesPath = referencesPath; - this.references = new ArrayList<>(); - this.batchRetriesConfig = batchRetriesConfig; - - if (autoBatchConfig != null) { - this.autoRunEnabled = true; - this.autoBatchConfig = autoBatchConfig; - this.executorService = Executors.newScheduledThreadPool(autoBatchConfig.poolSize); - this.delayedExecutor = new ExecutorServiceDelayedExecutor(executorService); - this.undoneFutures = Collections.synchronizedList(new ArrayList<>()); - } else { - this.autoRunEnabled = false; - this.autoBatchConfig = null; - this.executorService = null; - this.delayedExecutor = new SleepDelayedExecutor(); - this.undoneFutures = null; - } - } - - public static ReferencesBatcher create(HttpClient httpClient, Config config, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - return new ReferencesBatcher(httpClient, config, referencesPath, batchRetriesConfig, null); - } - - public static ReferencesBatcher createAuto(HttpClient httpClient, Config config, ReferencesPath referencesPath, - BatchRetriesConfig batchRetriesConfig, AutoBatchConfig autoBatchConfig) { - Assert.requiredNotNull(batchRetriesConfig, "batchRetriesConfig"); - Assert.requiredNotNull(autoBatchConfig, "autoBatchConfig"); - return new ReferencesBatcher(httpClient, config, referencesPath, batchRetriesConfig, autoBatchConfig); - } - - - public ReferencesBatcher withReference(BatchReference reference) { - return withReferences(reference); - } - - public ReferencesBatcher withReferences(BatchReference... references) { - this.references.addAll(Arrays.asList(references)); - autoRun(); - return this; - } - - public ReferencesBatcher withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - @Override - public Result run() { - if (autoRunEnabled) { - flush(); // fallback to flush in auto run enabled - return null; - } - - if (references.isEmpty()) { - return new Result<>(0, new BatchReferenceResponse[0], null); - } - - List batch = extractBatch(references.size()); - return runRecursively(batch, 0, 0, - (DelayedExecutor>) delayedExecutor); - } - - public void flush() { - if (!autoRunEnabled) { - run(); // fallback to run if auto run disabled - return; - } - - if (!references.isEmpty()) { - List batch = extractBatch(references.size()); - runInThread(batch); - } - - CompletableFuture[] futures = undoneFutures.toArray(new CompletableFuture[0]); - if (futures.length == 0) { - return; - } - - CompletableFuture.allOf(futures).join(); - } - - @Override - public void close() { - if (!autoRunEnabled) { - return; - } - - executorService.shutdown(); - try { - if (!executorService.awaitTermination(autoBatchConfig.awaitTerminationMs, TimeUnit.MILLISECONDS)) { - executorService.shutdownNow(); - } - } catch (InterruptedException e) { - executorService.shutdownNow(); - } - } - - private List extractBatch(int batchSize) { - List batch = new ArrayList<>(batchSize); - List sublist = references.subList(0, batchSize); - - batch.addAll(sublist); - sublist.clear(); - - return batch; - } - - private void autoRun() { - if (!autoRunEnabled) { - return; - } - - while (references.size() >= autoBatchConfig.batchSize) { - List batch = extractBatch(autoBatchConfig.batchSize); - runInThread(batch); - } - } - - private void runInThread(List batch) { - CompletableFuture> future = CompletableFuture.supplyAsync( - () -> createRunFuture(batch), - executorService - ).thenCompose(f -> f); - - if (autoBatchConfig.callback != null) { - future = future.whenComplete((result, e) -> autoBatchConfig.callback.accept(result)); - } - - CompletableFuture> undoneFuture = future; - undoneFutures.add(undoneFuture); - undoneFuture.whenComplete((result, ex) -> undoneFutures.remove(undoneFuture)); - } - - private CompletableFuture> createRunFuture(List batch) { - return runRecursively(batch, 0, 0, - (DelayedExecutor>>) delayedExecutor); - } - - private T runRecursively(List batch, int connectionErrorCount, int timeoutErrorCount, - DelayedExecutor delayedExecutor) { - Result result = internalRun(batch); - - if (result.hasErrors()) { - List messages = result.getError().getMessages(); - if (!messages.isEmpty()) { - Throwable throwable = messages.get(0).getThrowable(); - boolean executeAgain = false; - int delay = 0; - - if (throwable instanceof ConnectException) { - if (connectionErrorCount++ < batchRetriesConfig.maxConnectionRetries) { - executeAgain = true; - delay = connectionErrorCount * batchRetriesConfig.retriesIntervalMs; - } - } else if (throwable instanceof SocketTimeoutException) { - if (timeoutErrorCount++ < batchRetriesConfig.maxTimeoutRetries) { - executeAgain = true; - delay = timeoutErrorCount * batchRetriesConfig.retriesIntervalMs; - } - } - - if (executeAgain) { - int lambdaConnectionErrorCount = connectionErrorCount; - int lambdaTimeoutErrorCount = timeoutErrorCount; - List lambdaBatch = batch; - - return delayedExecutor.delayed( - delay, - () -> runRecursively(lambdaBatch, lambdaConnectionErrorCount, lambdaTimeoutErrorCount, delayedExecutor) - ); - } - } - } else { - batch = null; - } - - Result finalResult = createFinalResultFromLastResult(result, batch); - return delayedExecutor.now(finalResult); - } - - private Result internalRun(List batch) { - BatchReference[] payload = batch.toArray(new BatchReference[0]); - String path = referencesPath.buildCreate(ReferencesPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - Response resp = sendPostRequest(path, payload, BatchReferenceResponse[].class); - return new Result<>(resp); - } - - private Result createFinalResultFromLastResult( - Result lastResult, List failedBatch) { - - if (ObjectUtils.isEmpty(failedBatch)) { - return lastResult; - } - - String failedRefs = failedBatch.stream() - .map(ref -> ref.getFrom() + " => " + ref.getTo()) - .collect(Collectors.joining(", ")); - WeaviateErrorMessage failedRefsMessage = WeaviateErrorMessage.builder().message("Failed refs: " + failedRefs).build(); - List messages; - - int statusCode = 0; - if (lastResult.hasErrors()) { - statusCode = lastResult.getError().getStatusCode(); - List prevMessages = lastResult.getError().getMessages(); - messages = new ArrayList<>(prevMessages.size() + 1); - messages.addAll(prevMessages); - messages.add(failedRefsMessage); - } else { - messages = Collections.singletonList(failedRefsMessage); - } - - return new Result<>(statusCode, null, WeaviateErrorResponse.builder() - .error(messages) - .code(statusCode) - .build() - ); - } - - - - private interface DelayedExecutor { - T delayed(int delay, Supplier supplier); - T now(Result result); - } - - @RequiredArgsConstructor - private static class ExecutorServiceDelayedExecutor implements DelayedExecutor>> { - - private final ScheduledExecutorService executorService; - - @Override - public CompletableFuture> delayed(int delay, Supplier>> supplier) { - Executor executor = (runnable) -> executorService.schedule(runnable, delay, TimeUnit.MILLISECONDS); - return CompletableFuture.supplyAsync(supplier, executor).thenCompose(f -> f); - } - - @Override - public CompletableFuture> now(Result result) { - return CompletableFuture.completedFuture(result); - } - } - - - private static class SleepDelayedExecutor implements DelayedExecutor> { - - @Override - public Result delayed(int delay, Supplier> supplier) { - try { - Thread.sleep(delay); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - } - return supplier.get(); - } - - @Override - public Result now(Result result) { - return result; - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class BatchRetriesConfig { - - public static final int MAX_TIMEOUT_RETRIES = 3; - public static final int MAX_CONNECTION_RETRIES = 3; - public static final int RETRIES_INTERVAL = 2000; - - int maxTimeoutRetries; - int maxConnectionRetries; - int retriesIntervalMs; - - private BatchRetriesConfig(int maxTimeoutRetries, int maxConnectionRetries, int retriesIntervalMs) { - Assert.requireGreaterEqual(maxTimeoutRetries, 0, "maxTimeoutRetries"); - Assert.requireGreaterEqual(maxConnectionRetries, 0, "maxConnectionRetries"); - Assert.requireGreater(retriesIntervalMs, 0, "retriesIntervalMs"); - - this.maxTimeoutRetries = maxTimeoutRetries; - this.maxConnectionRetries = maxConnectionRetries; - this.retriesIntervalMs = retriesIntervalMs; - } - - public static BatchRetriesConfigBuilder defaultConfig() { - return BatchRetriesConfig.builder() - .maxTimeoutRetries(MAX_TIMEOUT_RETRIES) - .maxConnectionRetries(MAX_CONNECTION_RETRIES) - .retriesIntervalMs(RETRIES_INTERVAL); - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class AutoBatchConfig { - - public static final int BATCH_SIZE = 100; - public static final int POOL_SIZE = 1; - public static final int AWAIT_TERMINATION_MS = 10_000; - - int batchSize; - int poolSize; - int awaitTerminationMs; - Consumer> callback; - - private AutoBatchConfig(int batchSize, int poolSize, int awaitTerminationMs, - Consumer> callback) { - Assert.requireGreaterEqual(batchSize, 1, "batchSize"); - Assert.requireGreaterEqual(poolSize, 1, "corePoolSize"); - Assert.requireGreater(awaitTerminationMs, 0, "awaitTerminationMs"); - - this.batchSize = batchSize; - this.poolSize = poolSize; - this.awaitTerminationMs = awaitTerminationMs; - this.callback = callback; - } - - public static AutoBatchConfigBuilder defaultConfig() { - return AutoBatchConfig.builder() - .batchSize(BATCH_SIZE) - .poolSize(POOL_SIZE) - .awaitTerminationMs(AWAIT_TERMINATION_MS) - .callback(null); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/grpc/BatchObjectConverter.java b/src/main/java/io/weaviate/client/v1/batch/grpc/BatchObjectConverter.java deleted file mode 100644 index c2eade014..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/grpc/BatchObjectConverter.java +++ /dev/null @@ -1,311 +0,0 @@ -package io.weaviate.client.v1.batch.grpc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -import com.google.protobuf.ByteString; -import com.google.protobuf.Struct; -import com.google.protobuf.Value; - -import io.weaviate.client.base.util.CrossReference; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.grpc.GRPC; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.RequiredArgsConstructor; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@RequiredArgsConstructor -public class BatchObjectConverter { - - private final GrpcVersionSupport grpcVersionSupport; - - public WeaviateProtoBatch.BatchObject toBatchObject(WeaviateObject obj) { - WeaviateProtoBatch.BatchObject.Builder builder = WeaviateProtoBatch.BatchObject.newBuilder(); - - if (obj.getId() != null) { - builder.setUuid(obj.getId()); - } - if (obj.getClassName() != null) { - builder.setCollection(obj.getClassName()); - } - if (obj.getTenant() != null) { - builder.setTenant(obj.getTenant()); - } - if (obj.getProperties() != null) { - builder.setProperties(buildProperties(obj.getProperties())); - } - - Float[] vector = obj.getVector(); - if (vector != null) { - if (grpcVersionSupport.supportsVectorBytesField()) { - builder.setVectorBytes(GRPC.toByteString(vector)); - } else { - builder.addAllVector(Arrays.asList(vector)); - } - } - - Map vectors = obj.getVectors(); - if (vectors != null && !vectors.isEmpty()) { - List protoVectors = vectors.entrySet().stream() - .map(entry -> WeaviateProtoBase.Vectors.newBuilder() - .setName(entry.getKey()) - .setVectorBytes(GRPC.toByteString(entry.getValue())) - .setType(WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_SINGLE_FP32) - .build()) - .collect(Collectors.toList()); - builder.addAllVectors(protoVectors); - } - - Map multiVectors = obj.getMultiVectors(); - if (multiVectors != null && !multiVectors.isEmpty()) { - - builder.addAllVectors(multiVectors.entrySet().stream() - .map(entry -> { - ByteString sendThis = GRPC.toByteString(entry.getValue()); - return WeaviateProtoBase.Vectors.newBuilder() - .setName(entry.getKey()) - .setVectorBytes(sendThis) - .setType(WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_MULTI_FP32) - .build(); - }) - .collect(Collectors.toList())); - } - - return builder.build(); - } - - @AllArgsConstructor - @ToString - @FieldDefaults(level = AccessLevel.PRIVATE) - private static class Properties { - Map nonRefProperties; - List numberArrayProperties; - List intArrayProperties; - List textArrayProperties; - List booleanArrayProperties; - List objectProperties; - List objectArrayProperties; - List singleTargetRefProps; - List multiTargetRefProps; - } - - private static WeaviateProtoBatch.BatchObject.Properties buildProperties(Map properties) { - WeaviateProtoBatch.BatchObject.Properties.Builder builder = WeaviateProtoBatch.BatchObject.Properties.newBuilder(); - - Properties props = extractProperties(properties, true); - builder.setNonRefProperties(Struct.newBuilder().putAllFields(props.nonRefProperties).build()); - props.numberArrayProperties.forEach(builder::addNumberArrayProperties); - props.intArrayProperties.forEach(builder::addIntArrayProperties); - props.textArrayProperties.forEach(builder::addTextArrayProperties); - props.booleanArrayProperties.forEach(builder::addBooleanArrayProperties); - props.objectProperties.forEach(builder::addObjectProperties); - props.objectArrayProperties.forEach(builder::addObjectArrayProperties); - props.singleTargetRefProps.forEach(builder::addSingleTargetRefProps); - props.multiTargetRefProps.forEach(builder::addMultiTargetRefProps); - - return builder.build(); - } - - private static Properties extractProperties(Map properties, boolean rootLevel) { - Map nonRefProperties = new HashMap<>(); - List numberArrayProperties = new ArrayList<>(); - List intArrayProperties = new ArrayList<>(); - List textArrayProperties = new ArrayList<>(); - List booleanArrayProperties = new ArrayList<>(); - List objectProperties = new ArrayList<>(); - List objectArrayProperties = new ArrayList<>(); - List singleTargetRefProps = new ArrayList<>(); - List multiTargetRefProps = new ArrayList<>(); - // extract properties - for (Map.Entry e : properties.entrySet()) { - String propName = e.getKey(); - Object propValue = e.getValue(); - if (propValue instanceof String) { - nonRefProperties.put(propName, Value.newBuilder().setStringValue((String) propValue).build()); - continue; - } - if (propValue instanceof Boolean) { - nonRefProperties.put(propName, Value.newBuilder().setBoolValue((Boolean) propValue).build()); - continue; - } - if (propValue instanceof Integer) { - nonRefProperties.put(propName, Value.newBuilder().setNumberValue(((Integer) propValue).doubleValue()).build()); - continue; - } - if (propValue instanceof Long) { - nonRefProperties.put(propName, Value.newBuilder().setNumberValue(((Long) propValue).doubleValue()).build()); - continue; - } - if (propValue instanceof Float) { - nonRefProperties.put(propName, Value.newBuilder().setNumberValue(((Float) propValue).doubleValue()).build()); - continue; - } - if (propValue instanceof Double) { - nonRefProperties.put(propName, Value.newBuilder().setNumberValue((Double) propValue).build()); - continue; - } - if (propValue instanceof String[]) { - // TODO: handle ref properties - WeaviateProtoBase.TextArrayProperties textArrayProps = WeaviateProtoBase.TextArrayProperties.newBuilder() - .setPropName(propName).addAllValues(Arrays.asList((String[]) propValue)).build(); - textArrayProperties.add(textArrayProps); - continue; - } - if (propValue instanceof Boolean[]) { - WeaviateProtoBase.BooleanArrayProperties booleanArrayProps = WeaviateProtoBase.BooleanArrayProperties - .newBuilder() - .setPropName(propName).addAllValues(Arrays.asList((Boolean[]) propValue)).build(); - booleanArrayProperties.add(booleanArrayProps); - continue; - } - if (propValue instanceof Integer[]) { - List value = Arrays.stream((Integer[]) propValue).map(Integer::longValue).collect(Collectors.toList()); - WeaviateProtoBase.IntArrayProperties intArrayProps = WeaviateProtoBase.IntArrayProperties.newBuilder() - .setPropName(propName).addAllValues(value).build(); - intArrayProperties.add(intArrayProps); - continue; - } - if (propValue instanceof Long[]) { - WeaviateProtoBase.IntArrayProperties intArrayProps = WeaviateProtoBase.IntArrayProperties.newBuilder() - .setPropName(propName) - .addAllValues(Arrays.asList((Long[]) propValue)) - .build(); - intArrayProperties.add(intArrayProps); - continue; - } - if (propValue instanceof Float[]) { - List value = Arrays.stream((Float[]) propValue).map(Float::doubleValue).collect(Collectors.toList()); - WeaviateProtoBase.NumberArrayProperties numberArrayProps = WeaviateProtoBase.NumberArrayProperties.newBuilder() - .setPropName(propName).addAllValues(value).build(); - numberArrayProperties.add(numberArrayProps); - continue; - } - if (propValue instanceof Double[]) { - WeaviateProtoBase.NumberArrayProperties numberArrayProps = WeaviateProtoBase.NumberArrayProperties.newBuilder() - .setPropName(propName).addAllValues(Arrays.asList((Double[]) propValue)).build(); - numberArrayProperties.add(numberArrayProps); - continue; - } - if (propValue instanceof Map) { - Properties extractedProperties = extractProperties((Map) propValue, false); - WeaviateProtoBase.ObjectPropertiesValue.Builder objectPropertiesValue = WeaviateProtoBase.ObjectPropertiesValue - .newBuilder(); - objectPropertiesValue - .setNonRefProperties(Struct.newBuilder().putAllFields(extractedProperties.nonRefProperties).build()); - extractedProperties.numberArrayProperties.forEach(objectPropertiesValue::addNumberArrayProperties); - extractedProperties.intArrayProperties.forEach(objectPropertiesValue::addIntArrayProperties); - extractedProperties.textArrayProperties.forEach(objectPropertiesValue::addTextArrayProperties); - extractedProperties.booleanArrayProperties.forEach(objectPropertiesValue::addBooleanArrayProperties); - extractedProperties.objectProperties.forEach(objectPropertiesValue::addObjectProperties); - extractedProperties.objectArrayProperties.forEach(objectPropertiesValue::addObjectArrayProperties); - - WeaviateProtoBase.ObjectProperties objectProps = WeaviateProtoBase.ObjectProperties.newBuilder() - .setPropName(propName).setValue(objectPropertiesValue.build()).build(); - - objectProperties.add(objectProps); - continue; - } - if (propValue instanceof List) { - if (isCrossReference((List) propValue, rootLevel)) { - // it's a cross reference - List beacons = extractBeacons((List) propValue); - List crossReferences = beacons.stream() - .map(CrossReference::fromBeacon) - .collect(Collectors.toList()); - - Map> crefs = new HashMap<>(); - for (CrossReference cref : crossReferences) { - List uuids = crefs.get(cref.getClassName()); - if (uuids == null) { - uuids = new ArrayList<>(); - } - uuids.add(cref.getTargetID()); - crefs.put(cref.getClassName(), uuids); - } - - if (crefs.size() == 1) { - for (Map.Entry> crefEntry : crefs.entrySet()) { - WeaviateProtoBatch.BatchObject.SingleTargetRefProps singleTargetCrossRefs = WeaviateProtoBatch.BatchObject.SingleTargetRefProps - .newBuilder() - .setPropName(propName).addAllUuids(crefEntry.getValue()).build(); - singleTargetRefProps.add(singleTargetCrossRefs); - } - } - if (crefs.size() > 1) { - for (Map.Entry> crefEntry : crefs.entrySet()) { - WeaviateProtoBatch.BatchObject.MultiTargetRefProps multiTargetCrossRefs = WeaviateProtoBatch.BatchObject.MultiTargetRefProps - .newBuilder() - .setPropName(propName).addAllUuids(crefEntry.getValue()).setTargetCollection(crefEntry.getKey()) - .build(); - multiTargetRefProps.add(multiTargetCrossRefs); - } - } - } else { - // it's an object - List objectPropertiesValues = new ArrayList<>(); - for (Object propValueObject : (List) propValue) { - if (propValueObject instanceof Map) { - Properties extractedProperties = extractProperties((Map) propValueObject, false); - WeaviateProtoBase.ObjectPropertiesValue.Builder objectPropertiesValue = WeaviateProtoBase.ObjectPropertiesValue - .newBuilder(); - objectPropertiesValue - .setNonRefProperties(Struct.newBuilder().putAllFields(extractedProperties.nonRefProperties).build()); - extractedProperties.numberArrayProperties.forEach(objectPropertiesValue::addNumberArrayProperties); - extractedProperties.intArrayProperties.forEach(objectPropertiesValue::addIntArrayProperties); - extractedProperties.textArrayProperties.forEach(objectPropertiesValue::addTextArrayProperties); - extractedProperties.booleanArrayProperties.forEach(objectPropertiesValue::addBooleanArrayProperties); - extractedProperties.objectProperties.forEach(objectPropertiesValue::addObjectProperties); - extractedProperties.objectArrayProperties.forEach(objectPropertiesValue::addObjectArrayProperties); - - objectPropertiesValues.add(objectPropertiesValue.build()); - } - } - - WeaviateProtoBase.ObjectArrayProperties objectArrayProps = WeaviateProtoBase.ObjectArrayProperties - .newBuilder() - .setPropName(propName).addAllValues(objectPropertiesValues).build(); - - objectArrayProperties.add(objectArrayProps); - } - } - } - return new Properties(nonRefProperties, numberArrayProperties, intArrayProperties, textArrayProperties, - booleanArrayProperties, objectProperties, objectArrayProperties, singleTargetRefProps, multiTargetRefProps); - } - - private static boolean isCrossReference(List propValue, boolean rootLevel) { - if (rootLevel) { - for (Object element : propValue) { - if (element instanceof Map) { - Map valueMap = ((Map) element); - if (valueMap.size() > 1 || (valueMap.size() == 1 - && (valueMap.get("beacon") == null || !(valueMap.get("beacon") instanceof String)))) { - return false; - } - } - } - return true; - } - return false; - } - - private static List extractBeacons(List propValue) { - List beacons = new ArrayList<>(); - for (Object element : propValue) { - if (element instanceof Map) { - Map valueMap = ((Map) element); - beacons.add((String) valueMap.get("beacon")); - } - } - return beacons; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteOutput.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteOutput.java deleted file mode 100644 index 6f07690b0..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteOutput.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -public interface BatchDeleteOutput { - - String VERBOSE = "verbose"; - String MINIMAL = "minimal"; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResponse.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResponse.java deleted file mode 100644 index 93f18f896..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResponse.java +++ /dev/null @@ -1,83 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import io.weaviate.client.v1.filters.WhereFilter; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BatchDeleteResponse { - - Match match; - String output; - Boolean dryRun; - Results results; - - - @Getter - @Setter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Match { - - @SerializedName("class") - String className; - @SerializedName("where") - WhereFilter whereFilter; - } - - @Getter - @Setter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Results { - - Long matches; - Long limit; - Long successful; - Long failed; - ResultObject[] objects; - } - - @Getter - @Setter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ResultObject { - - String id; - String status; - Errors errors; - } - - @Getter - @Setter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Errors { - - Error[] error; - } - - @Getter - @Setter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Error { - - String message; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResultStatus.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResultStatus.java deleted file mode 100644 index 142ee8f1e..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchDeleteResultStatus.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -public interface BatchDeleteResultStatus { - - String SUCCESS = "SUCCESS"; - String FAILED = "FAILED"; - String DRYRUN = "DRYRUN"; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchReference.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchReference.java deleted file mode 100644 index 78b34a87f..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchReference.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BatchReference { - String from; - String to; - String tenant; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponse.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponse.java deleted file mode 100644 index b8948d38e..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponse.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BatchReferenceResponse { - String from; - String to; - BatchReferenceResponseAO1Result result; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseAO1Result.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseAO1Result.java deleted file mode 100644 index 8d4f320c6..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseAO1Result.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.util.List; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class BatchReferenceResponseAO1Result { - ErrorResponse errors; - String status; - - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ErrorResponse { - List error; - } - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ErrorItem { - String message; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseStatus.java b/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseStatus.java deleted file mode 100644 index 2fc0129dc..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseStatus.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -public interface BatchReferenceResponseStatus { - - String SUCCESS = "SUCCESS"; - String PENDING = "PENDING"; - String FAILED = "FAILED"; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponse.java b/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponse.java deleted file mode 100644 index 0b3e70b39..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponse.java +++ /dev/null @@ -1,36 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import java.util.Map; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.v1.data.model.Deprecation; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ObjectGetResponse { - String id; - @SerializedName("class") - String className; - Long creationTimeUnix; - Long lastUpdateTimeUnix; - Map properties; - Map additional; - Float[] vector; - Map vectors; - Map multiVectors; - Object vectorWeights; - String tenant; - - Deprecation[] deprecations; - ObjectsGetResponseAO2Result result; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponseStatus.java b/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponseStatus.java deleted file mode 100644 index d71d68468..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/ObjectGetResponseStatus.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -public interface ObjectGetResponseStatus { - - String SUCCESS = "SUCCESS"; - String PENDING = "PENDING"; - String FAILED = "FAILED"; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/ObjectsBatchRequestBody.java b/src/main/java/io/weaviate/client/v1/batch/model/ObjectsBatchRequestBody.java deleted file mode 100644 index 44a2dd83a..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/ObjectsBatchRequestBody.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import io.weaviate.client.v1.data.model.WeaviateObject; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ObjectsBatchRequestBody { - String[] fields; - WeaviateObject[] objects; -} diff --git a/src/main/java/io/weaviate/client/v1/batch/model/ObjectsGetResponseAO2Result.java b/src/main/java/io/weaviate/client/v1/batch/model/ObjectsGetResponseAO2Result.java deleted file mode 100644 index faac641b5..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/model/ObjectsGetResponseAO2Result.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ObjectsGetResponseAO2Result { - ErrorResponse errors; - String status; - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ErrorResponse { - List error; - - public ErrorResponse(String... errors) { - this.error = Arrays.stream(errors).map(ErrorItem::new).collect(Collectors.toList()); - } - } - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - @AllArgsConstructor - public static class ErrorItem { - String message; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/util/ObjectsPath.java b/src/main/java/io/weaviate/client/v1/batch/util/ObjectsPath.java deleted file mode 100644 index 0cc467be7..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/util/ObjectsPath.java +++ /dev/null @@ -1,72 +0,0 @@ -package io.weaviate.client.v1.batch.util; - -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.base.util.TriConsumer; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; - -public class ObjectsPath { - - public String buildCreate(Params params) { - return build( - params, - this::addQueryConsistencyLevel - ); - } - - public String buildDelete(Params params) { - return build( - params, - this::addQueryConsistencyLevel, - this::addQueryTenant - ); - } - - - @SafeVarargs - private final String build(Params params, TriConsumer, List>... appenders) { - Objects.requireNonNull(params); - - List pathParams = new ArrayList<>(); - List queryParams = new ArrayList<>(); - - pathParams.add("/batch/objects"); - Arrays.stream(appenders).forEach(consumer -> consumer.accept(params, pathParams, queryParams)); - - String path = String.join("/", pathParams); - if (!queryParams.isEmpty()) { - return path + "?" + String.join("&", queryParams); - } - return path; - } - - private void addQueryConsistencyLevel(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.consistencyLevel)) { - queryParams.add(UrlEncoder.encodeQueryParam("consistency_level", params.consistencyLevel)); - } - } - - private void addQueryTenant(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.tenant)) { - queryParams.add(UrlEncoder.encodeQueryParam("tenant", params.tenant)); - } - } - - - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Params { - - String consistencyLevel; - String tenant; - } -} diff --git a/src/main/java/io/weaviate/client/v1/batch/util/ReferencesPath.java b/src/main/java/io/weaviate/client/v1/batch/util/ReferencesPath.java deleted file mode 100644 index 201f46700..000000000 --- a/src/main/java/io/weaviate/client/v1/batch/util/ReferencesPath.java +++ /dev/null @@ -1,57 +0,0 @@ -package io.weaviate.client.v1.batch.util; - -import io.weaviate.client.base.util.TriConsumer; -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; - -public class ReferencesPath { - - public String buildCreate(Params params) { - return build( - params, - this::addQueryConsistencyLevel - ); - } - - @SafeVarargs - private final String build(Params params, TriConsumer, List>... appenders) { - Objects.requireNonNull(params); - - List pathParams = new ArrayList<>(); - List queryParams = new ArrayList<>(); - - pathParams.add("/batch/references"); - Arrays.stream(appenders).forEach(consumer -> consumer.accept(params, pathParams, queryParams)); - - String path = String.join("/", pathParams); - if (!queryParams.isEmpty()) { - return path + "?" + String.join("&", queryParams); - } - return path; - } - - - private void addQueryConsistencyLevel(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.consistencyLevel)) { - queryParams.add(UrlEncoder.encodeQueryParam("consistency_level", params.consistencyLevel)); - } - } - - - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Params { - - String consistencyLevel; - } -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/Classifications.java b/src/main/java/io/weaviate/client/v1/classifications/Classifications.java deleted file mode 100644 index 7547423f6..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/Classifications.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.classifications; - -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.classifications.api.Getter; -import io.weaviate.client.v1.classifications.api.Scheduler; -import io.weaviate.client.Config; - -public class Classifications { - private final Config config; - private final HttpClient httpClient; - - public Classifications(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public Scheduler scheduler() { - return new Scheduler(httpClient, config); - } - - public Getter getter() { - return new Getter(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/api/Getter.java b/src/main/java/io/weaviate/client/v1/classifications/api/Getter.java deleted file mode 100644 index 2339134a8..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/api/Getter.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.classifications.api; - -import io.weaviate.client.v1.classifications.model.Classification; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class Getter extends BaseClient implements ClientResult { - - private String id; - - public Getter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Getter withID(String id) { - this.id = id; - return this; - } - - @Override - public Result run() { - if (StringUtils.isBlank(id)) { - return null; - } - String path = String.format("/classifications/%s", id); - Response resp = sendGetRequest(path, Classification.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/api/Scheduler.java b/src/main/java/io/weaviate/client/v1/classifications/api/Scheduler.java deleted file mode 100644 index 43c5928dd..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/api/Scheduler.java +++ /dev/null @@ -1,129 +0,0 @@ -package io.weaviate.client.v1.classifications.api; - -import io.weaviate.client.v1.classifications.model.Classification; -import io.weaviate.client.v1.classifications.model.ClassificationFilters; -import org.apache.commons.lang3.ObjectUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.filters.WhereFilter; - -public class Scheduler extends BaseClient implements ClientResult { - - private String classificationType; - private String className; - private String[] classifyProperties; - private String[] basedOnProperties; - private WhereFilter sourceWhereFilter; - private WhereFilter trainingSetWhereFilter; - private WhereFilter targetWhereFilter; - private Boolean waitForCompletion; - private Object settings; - - private Getter getter; - - public Scheduler(HttpClient httpClient, Config config) { - super(httpClient, config); - this.getter = new Getter(httpClient, config); - this.waitForCompletion = false; - } - - public Scheduler withType(String classificationType) { - this.classificationType = classificationType; - return this; - } - - public Scheduler withClassName(String className) { - this.className = className; - return this; - } - - public Scheduler withClassifyProperties(String[] classifyProperties) { - this.classifyProperties = classifyProperties; - return this; - } - - public Scheduler withBasedOnProperties(String[] basedOnProperties) { - this.basedOnProperties = basedOnProperties; - return this; - } - - public Scheduler withSourceWhereFilter(WhereFilter whereFilter) { - this.sourceWhereFilter = whereFilter; - return this; - } - - public Scheduler withTrainingSetWhereFilter(WhereFilter whereFilter) { - this.trainingSetWhereFilter = whereFilter; - return this; - } - - public Scheduler withTargetWhereFilter(WhereFilter whereFilter) { - this.targetWhereFilter = whereFilter; - return this; - } - - public Scheduler withSettings(Object settings) { - this.settings = settings; - return this; - } - - public Scheduler withWaitForCompletion() { - this.waitForCompletion = true; - return this; - } - - private Classification waitForCompletion(String id) throws InterruptedException { - for (; ; ) { - Result result = getter.withID(id).run(); - if (result == null || result.getResult() == null) { - return null; - } - Classification runningClassification = result.getResult(); - if (runningClassification.getStatus() == "running") { - Thread.sleep(2000); - } else { - return runningClassification; - } - } - } - - @Override - public Result run() { - Classification config = Classification.builder() - .basedOnProperties(basedOnProperties) - .className(className) - .classifyProperties(classifyProperties) - .type(classificationType) - .settings(settings) - .filters(getClassificationFilters(sourceWhereFilter, targetWhereFilter, trainingSetWhereFilter)) - .build(); - Response resp = sendPostRequest("/classifications", config, Classification.class); - if (resp.getStatusCode() == 201) { - if (waitForCompletion) { - try { - Classification c = waitForCompletion(resp.getBody().getId()); - return new Result<>(resp.getStatusCode(), c, null); - } catch (InterruptedException e) { - return new Result<>(resp); - } - } - return new Result<>(resp); - } - return new Result<>(resp); - } - - private ClassificationFilters getClassificationFilters(WhereFilter sourceWhere, WhereFilter targetWhere, WhereFilter trainingSetWhere) { - if (ObjectUtils.anyNotNull(sourceWhere, targetWhere, trainingSetWhere)) { - return ClassificationFilters.builder() - .sourceWhere(sourceWhere) - .targetWhere(targetWhere) - .trainingSetWhere(trainingSetWhere) - .build(); - } - return null; - } -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/model/Classification.java b/src/main/java/io/weaviate/client/v1/classifications/model/Classification.java deleted file mode 100644 index 6671ae00d..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/model/Classification.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.classifications.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class Classification { - String[] basedOnProperties; - @SerializedName("class") - String className; - String[] classifyProperties; - String error; - ClassificationFilters filters; - String id; - ClassificationMeta meta; - Object settings; - String status; - String type; -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationFilters.java b/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationFilters.java deleted file mode 100644 index e97b6b8de..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationFilters.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.v1.classifications.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import io.weaviate.client.v1.filters.WhereFilter; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ClassificationFilters { - WhereFilter sourceWhere; - WhereFilter targetWhere; - WhereFilter trainingSetWhere; -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationMeta.java b/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationMeta.java deleted file mode 100644 index cf556478f..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationMeta.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.classifications.model; - -import java.util.Date; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ClassificationMeta { - Date completed; - Long count; - Long countFailed; - Long countSucceeded; - Date started; -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationType.java b/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationType.java deleted file mode 100644 index 79abb5826..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/model/ClassificationType.java +++ /dev/null @@ -1,13 +0,0 @@ -package io.weaviate.client.v1.classifications.model; - -public final class ClassificationType { - // KNN (k nearest neighbours) a non parametric classification based on training data - public static final String KNN = "knn"; - // Contextual classification labels a data object with - // the closest label based on their vector position (which describes the context) - public static final String Contextual = "text2vec-contextionary"; - // ZeroShot classification labels a data object with - // the closest label based on their vector position (which describes the context) - // It can be used with any vectorizer or custom vectors. - public static final String ZeroShot = "zeroshot"; -} diff --git a/src/main/java/io/weaviate/client/v1/classifications/model/ParamsKNN.java b/src/main/java/io/weaviate/client/v1/classifications/model/ParamsKNN.java deleted file mode 100644 index 0a3451430..000000000 --- a/src/main/java/io/weaviate/client/v1/classifications/model/ParamsKNN.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.classifications.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class ParamsKNN { - Integer k; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/Cluster.java b/src/main/java/io/weaviate/client/v1/cluster/Cluster.java deleted file mode 100644 index 51b3b057d..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/Cluster.java +++ /dev/null @@ -1,36 +0,0 @@ -package io.weaviate.client.v1.cluster; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.cluster.api.NodesStatusGetter; -import io.weaviate.client.v1.cluster.api.Replicator; -import io.weaviate.client.v1.cluster.api.ShardingStateQuerier; -import io.weaviate.client.v1.cluster.api.replication.Replication; - -public class Cluster { - - private final Config config; - private final HttpClient httpClient; - - public Cluster(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public Replication replication() { - return new Replication(httpClient, config); - } - - public NodesStatusGetter nodesStatusGetter() { - return new NodesStatusGetter(httpClient, config); - } - - public ShardingStateQuerier shardingStateQuerier() { - return new ShardingStateQuerier(httpClient, config); - } - - public Replicator replicator() { - return new Replicator(httpClient, config); - } - -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/NodesStatusGetter.java b/src/main/java/io/weaviate/client/v1/cluster/api/NodesStatusGetter.java deleted file mode 100644 index c62f20842..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/NodesStatusGetter.java +++ /dev/null @@ -1,65 +0,0 @@ -package io.weaviate.client.v1.cluster.api; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; - -public class NodesStatusGetter extends BaseClient implements ClientResult { - private String className; - private Map queryParams = new HashMap<>(); - - public NodesStatusGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public NodesStatusGetter withClassName(String className) { - this.className = className; - return this; - } - - public NodesStatusGetter withShard(String shard) { - this.queryParams.put("shard", shard); - return this; - } - - public NodesStatusGetter withOutput(String output) { - this.queryParams.put("output", output); - return this; - } - - @Override - public Result run() { - return new Result<>(sendGetRequest(path(), NodesStatusResponse.class)); - } - - private String path() { - String path = "/nodes"; - - if (StringUtils.isNotBlank(className)) { - path += "/" + UrlEncoder.encodePathParam(className); - } - - List query = new ArrayList<>(); - for (Entry qp : queryParams.entrySet()) { - query.add(UrlEncoder.encodeQueryParam(qp.getKey(), qp.getValue().toString())); - } - - if (!query.isEmpty()) { - path += "?" + String.join("&", query); - } - - return path; - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/Replicator.java b/src/main/java/io/weaviate/client/v1/cluster/api/Replicator.java deleted file mode 100644 index 178c49b34..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/Replicator.java +++ /dev/null @@ -1,75 +0,0 @@ -package io.weaviate.client.v1.cluster.api; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.cluster.api.Replicator.ResponseBody; -import io.weaviate.client.v1.cluster.model.ReplicationType; -import lombok.Getter; - -public class Replicator extends BaseClient implements ClientResult { - private String className; - private String shard; - private String sourceNode; - private String targetNode; - private ReplicationType replicationType; - - public Replicator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Replicator withClassName(String className) { - this.className = className; - return this; - } - - public Replicator withShard(String shard) { - this.shard = shard; - return this; - } - - public Replicator withSourceNode(String sourceNode) { - this.sourceNode = sourceNode; - return this; - } - - public Replicator withTargetNode(String targetNode) { - this.targetNode = targetNode; - return this; - } - - public Replicator withReplicationType(ReplicationType replicationType) { - this.replicationType = replicationType; - return this; - } - - class RequestBody { - @SerializedName("collection") - String className = Replicator.this.className; - @SerializedName("shard") - String shard = Replicator.this.shard; - @SerializedName("sourceNode") - String sourceNode = Replicator.this.sourceNode; - @SerializedName("targetNode") - String targetNode = Replicator.this.targetNode; - @SerializedName("type") - ReplicationType replicationType = Replicator.this.replicationType; - } - - @Getter - static class ResponseBody { - @SerializedName("id") - String replicationId; - } - - @Override - public Result run() { - return Result.map( - sendPostRequest("/replication/replicate", new RequestBody(), ResponseBody.class), - ResponseBody::getReplicationId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/ShardingStateQuerier.java b/src/main/java/io/weaviate/client/v1/cluster/api/ShardingStateQuerier.java deleted file mode 100644 index 2c6b3768b..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/ShardingStateQuerier.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.cluster.api; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.cluster.api.ShardingStateQuerier.ResponseBody; -import io.weaviate.client.v1.cluster.model.ShardingState; -import lombok.Getter; - -public class ShardingStateQuerier extends BaseClient implements ClientResult { - private String className; - private String shard; - - public ShardingStateQuerier(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ShardingStateQuerier withClassName(String className) { - this.className = className; - return this; - } - - public ShardingStateQuerier withShard(String shard) { - this.shard = shard; - return this; - } - - @Getter - static class ResponseBody { - @SerializedName("shardingState") - ShardingState state; - } - - @Override - public Result run() { - String path = "/replication/sharding-state?" + UrlEncoder.encodeQueryParam("collection", className); - if (shard != null) { - path += "&" + UrlEncoder.encodeQueryParam("shard", shard); - } - return Result.map(sendGetRequest(path, ResponseBody.class), ResponseBody::getState); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/Replication.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/Replication.java deleted file mode 100644 index 40c8a6664..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/Replication.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationAllDeleter; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationAllGetter; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationCanceler; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationDeleter; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationGetter; -import io.weaviate.client.v1.cluster.api.replication.api.ReplicationQuerier; - -public class Replication { - - private final Config config; - private final HttpClient httpClient; - - public Replication(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public ReplicationGetter getter() { - return new ReplicationGetter(httpClient, config); - } - - public ReplicationAllGetter allGetter() { - return new ReplicationAllGetter(httpClient, config); - } - - public ReplicationQuerier querier() { - return new ReplicationQuerier(httpClient, config); - } - - public ReplicationCanceler canceler() { - return new ReplicationCanceler(httpClient, config); - } - - public ReplicationDeleter deleter() { - return new ReplicationDeleter(httpClient, config); - } - - public ReplicationAllDeleter allDeleter() { - return new ReplicationAllDeleter(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllDeleter.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllDeleter.java deleted file mode 100644 index c8bb30ccd..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllDeleter.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class ReplicationAllDeleter extends BaseClient implements ClientResult { - - public ReplicationAllDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result run() { - return Result - .voidToBoolean(sendDeleteRequest("/replication/replicate", null, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllGetter.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllGetter.java deleted file mode 100644 index 358957c1e..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationAllGetter.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationAllGetter extends BaseClient - implements ClientResult> { - - public ReplicationAllGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result> run() { - return Result.toList(sendGetRequest("/replication/replicate/list?includeHistory=true", ReplicateOperation[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationCanceler.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationCanceler.java deleted file mode 100644 index f79d793a4..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationCanceler.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class ReplicationCanceler extends BaseClient implements ClientResult { - private String uuid; - - public ReplicationCanceler(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ReplicationCanceler withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - @Override - public Result run() { - return Result - .voidToBoolean(sendPostRequest("/replication/replicate/" + uuid + "/cancel", null, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationDeleter.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationDeleter.java deleted file mode 100644 index 3f0261d65..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationDeleter.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class ReplicationDeleter extends BaseClient implements ClientResult { - private String uuid; - - public ReplicationDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ReplicationDeleter withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - @Override - public Result run() { - return Result - .voidToBoolean(sendDeleteRequest("/replication/replicate/" + uuid, null, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationGetter.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationGetter.java deleted file mode 100644 index 8daa34ae4..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationGetter.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationGetter extends BaseClient implements ClientResult { - private String uuid; - private Boolean includeHistory; - - public ReplicationGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ReplicationGetter withUuid(String uuid) { - this.uuid = uuid; - return this; - } - - public ReplicationGetter withIncludeHistory(boolean includeHistory) { - this.includeHistory = includeHistory; - return this; - } - - @Override - public Result run() { - String path = "/replication/replicate/" + uuid; - if (includeHistory != null) { - path += "?" + UrlEncoder.encodeQueryParam("includeHistory", includeHistory.toString()); - } - return new Result<>(sendGetRequest(path, ReplicateOperation.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationQuerier.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationQuerier.java deleted file mode 100644 index d2ca4824a..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/api/ReplicationQuerier.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.api; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; - -public class ReplicationQuerier extends BaseClient - implements ClientResult> { - private Map queryParams = new HashMap<>(); - - public ReplicationQuerier(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ReplicationQuerier withClassName(String className) { - this.queryParams.put("collection", className); - return this; - } - - public ReplicationQuerier withShard(String shard) { - this.queryParams.put("shard", shard); - return this; - } - - public ReplicationQuerier withTargetNode(String targetNode) { - this.queryParams.put("targetNode", targetNode); - return this; - } - - public ReplicationQuerier withIncludeHistory(boolean includeHistory) { - this.queryParams.put("includeHistory", includeHistory); - return this; - } - - @Override - public Result> run() { - String path = "/replication/replicate/list"; - - List query = new ArrayList<>(); - for (Entry qp : queryParams.entrySet()) { - query.add(UrlEncoder.encodeQueryParam(qp.getKey(), qp.getValue().toString())); - } - - if (!query.isEmpty()) { - path += "?" + String.join("&", query); - } - - return Result.toList(sendGetRequest(path, ReplicateOperation[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperation.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperation.java deleted file mode 100644 index 4967fc5b6..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperation.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.model; - -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.v1.cluster.model.ReplicationType; -import lombok.Getter; -import lombok.ToString; - -@Getter -@ToString -public class ReplicateOperation { - @SerializedName("id") - String uuid; - @SerializedName("collection") - String className; - @SerializedName("shard") - String shard; - @SerializedName("sourceNode") - String sourceNode; - @SerializedName("targetNode") - String targetNode; - @SerializedName("status") - ReplicateOperationStatus status; - @SerializedName("statusHistory") - List statusHistory; - @SerializedName("type") - ReplicationType transferType; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationState.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationState.java deleted file mode 100644 index 547b6aaeb..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationState.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.model; - -import com.google.gson.annotations.SerializedName; - -public enum ReplicateOperationState { - @SerializedName("REGISTERED") - REGISTERED, - @SerializedName("HYDRATING") - HYDRATING, - @SerializedName("FINALIZING") - FINALIZING, - @SerializedName("DEHYDRATING") - DEHYDRATING, - @SerializedName("READY") - READY, - @SerializedName("CANCELLED") - CANCELLED; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationStatus.java b/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationStatus.java deleted file mode 100644 index 8a5806989..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/api/replication/model/ReplicateOperationStatus.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.cluster.api.replication.model; - -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import lombok.Getter; -import lombok.ToString; - -@Getter -@ToString -public class ReplicateOperationStatus { - @SerializedName("state") - ReplicateOperationState state; - @SerializedName("errors") - List errors; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/model/NodeStatusOutput.java b/src/main/java/io/weaviate/client/v1/cluster/model/NodeStatusOutput.java deleted file mode 100644 index 72337907a..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/model/NodeStatusOutput.java +++ /dev/null @@ -1,6 +0,0 @@ -package io.weaviate.client.v1.cluster.model; - -public interface NodeStatusOutput { - String VERBOSE = "verbose"; - String MINIMAL = "minimal"; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/model/NodesStatusResponse.java b/src/main/java/io/weaviate/client/v1/cluster/model/NodesStatusResponse.java deleted file mode 100644 index ef808e369..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/model/NodesStatusResponse.java +++ /dev/null @@ -1,61 +0,0 @@ -package io.weaviate.client.v1.cluster.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class NodesStatusResponse { - - NodeStatus[] nodes; - - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class NodeStatus { - - String name; - String status; - String version; - String gitHash; - Stats stats; - ShardStatus[] shards; - } - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Stats { - - Long shardCount; - Long objectCount; - } - - @Getter - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ShardStatus { - - String name; - @SerializedName("class") - String className; - Long objectCount; - } - - public interface Status { - - String HEALTHY = "HEALTHY"; - String UNHEALTHY = "UNHEALTHY"; - String UNAVAILABLE = "UNAVAILABLE"; - } -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/model/ReplicationType.java b/src/main/java/io/weaviate/client/v1/cluster/model/ReplicationType.java deleted file mode 100644 index effe190af..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/model/ReplicationType.java +++ /dev/null @@ -1,10 +0,0 @@ -package io.weaviate.client.v1.cluster.model; - -import com.google.gson.annotations.SerializedName; - -public enum ReplicationType { - @SerializedName("COPY") - COPY, - @SerializedName("MOVE") - MOVE; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/model/ShardReplicas.java b/src/main/java/io/weaviate/client/v1/cluster/model/ShardReplicas.java deleted file mode 100644 index b14c0a2e5..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/model/ShardReplicas.java +++ /dev/null @@ -1,15 +0,0 @@ -package io.weaviate.client.v1.cluster.model; - -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import lombok.Getter; - -@Getter -public class ShardReplicas { - @SerializedName("shard") - String name; - @SerializedName("replicas") - List replicas; -} diff --git a/src/main/java/io/weaviate/client/v1/cluster/model/ShardingState.java b/src/main/java/io/weaviate/client/v1/cluster/model/ShardingState.java deleted file mode 100644 index 50914899d..000000000 --- a/src/main/java/io/weaviate/client/v1/cluster/model/ShardingState.java +++ /dev/null @@ -1,15 +0,0 @@ -package io.weaviate.client.v1.cluster.model; - -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import lombok.Getter; - -@Getter -public class ShardingState { - @SerializedName("collection") - String className; - @SerializedName("shards") - List shards; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/Contextionary.java b/src/main/java/io/weaviate/client/v1/contextionary/Contextionary.java deleted file mode 100644 index c59331d76..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/Contextionary.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.contextionary; - -import io.weaviate.client.v1.contextionary.api.ConceptsGetter; -import io.weaviate.client.v1.contextionary.api.ExtensionCreator; -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; - -public class Contextionary { - private final Config config; - private final HttpClient httpClient; - - public Contextionary(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public ConceptsGetter conceptsGetter() { - return new ConceptsGetter(httpClient, config); - } - - public ExtensionCreator extensionCreator() { - return new ExtensionCreator(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/api/ConceptsGetter.java b/src/main/java/io/weaviate/client/v1/contextionary/api/ConceptsGetter.java deleted file mode 100644 index cbb3a2919..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/api/ConceptsGetter.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.contextionary.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.contextionary.model.C11yWordsResponse; - -public class ConceptsGetter extends BaseClient implements ClientResult { - - private String concept; - - public ConceptsGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ConceptsGetter withConcept(String concept) { - this.concept = concept; - return this; - } - - @Override - public Result run() { - String path = String.format("/modules/text2vec-contextionary/concepts/%s", concept); - Response resp = sendGetRequest(path, C11yWordsResponse.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/api/ExtensionCreator.java b/src/main/java/io/weaviate/client/v1/contextionary/api/ExtensionCreator.java deleted file mode 100644 index 150e8d03b..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/api/ExtensionCreator.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.contextionary.api; - -import java.util.stream.Collectors; -import java.util.stream.Stream; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.contextionary.model.C11yExtension; - -public class ExtensionCreator extends BaseClient implements ClientResult { - - private C11yExtension.C11yExtensionBuilder extension; - - public ExtensionCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - this.extension = C11yExtension.builder().weight(1.0f); - } - - public ExtensionCreator withConcept(String concept) { - this.extension.concept(concept); - return this; - } - - public ExtensionCreator withDefinition(String definition) { - this.extension.definition(definition); - return this; - } - - public ExtensionCreator withWeight(Float weight) { - this.extension.weight(weight); - return this; - } - - @Override - public Result run() { - C11yExtension extension = this.extension.build(); - if (extension.getWeight() > 1 || extension.getWeight() < 0) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("weight has to be between 0 and 1") - .build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())) - .build(); - return new Result<>(500, false, errors); - } - Response resp = sendPostRequest("/modules/text2vec-contextionary/extensions", extension, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yExtension.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yExtension.java deleted file mode 100644 index 19bb1a3d8..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yExtension.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yExtension { - String concept; - String definition; - Float weight; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yNearestNeighbor.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yNearestNeighbor.java deleted file mode 100644 index 7f23e751c..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yNearestNeighbor.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yNearestNeighbor { - Float distance; - String word; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponse.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponse.java deleted file mode 100644 index ddf7585c7..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponse.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yWordsResponse { - C11yWordsResponseConcatenatedWord concatenatedWord; - C11yWordsResponseIndividualWordsItems[] individualWords; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseConcatenatedWord.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseConcatenatedWord.java deleted file mode 100644 index 5e8ab2424..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseConcatenatedWord.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yWordsResponseConcatenatedWord { - C11yNearestNeighbor[] concatenatedNearestNeighbors; - Float[] concatenatedVector; - String concatenatedWord; - String[] singleWords; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems.java deleted file mode 100644 index b601e5704..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yWordsResponseIndividualWordsItems { - C11yWordsResponseIndividualWordsItems0Info info; - Boolean present; - String word; -} diff --git a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems0Info.java b/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems0Info.java deleted file mode 100644 index 6669a4d9d..000000000 --- a/src/main/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseIndividualWordsItems0Info.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@AllArgsConstructor -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class C11yWordsResponseIndividualWordsItems0Info { - C11yNearestNeighbor[] nearestNeighbors; - Float[] vector; -} diff --git a/src/main/java/io/weaviate/client/v1/data/Data.java b/src/main/java/io/weaviate/client/v1/data/Data.java deleted file mode 100644 index 09da090d3..000000000 --- a/src/main/java/io/weaviate/client/v1/data/Data.java +++ /dev/null @@ -1,74 +0,0 @@ -package io.weaviate.client.v1.data; - -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.data.api.ObjectCreator; -import io.weaviate.client.v1.data.api.ObjectDeleter; -import io.weaviate.client.v1.data.api.ObjectUpdater; -import io.weaviate.client.v1.data.api.ObjectValidator; -import io.weaviate.client.v1.data.api.ObjectsChecker; -import io.weaviate.client.v1.data.api.ObjectsGetter; -import io.weaviate.client.v1.data.api.ReferenceCreator; -import io.weaviate.client.v1.data.api.ReferenceDeleter; -import io.weaviate.client.v1.data.api.ReferenceReplacer; -import io.weaviate.client.v1.data.builder.ReferencePayloadBuilder; -import io.weaviate.client.v1.data.util.ObjectsPath; -import io.weaviate.client.v1.data.util.ReferencesPath; -import io.weaviate.client.Config; - -public class Data { - private final Config config; - private final HttpClient httpClient; - private final ObjectsPath objectsPath; - private final ReferencesPath referencesPath; - private final BeaconPath beaconPath; - - public Data(HttpClient httpClient, Config config, DbVersionSupport dbVersionSupport) { - this.config = config; - this.httpClient = httpClient; - this.objectsPath = new ObjectsPath(dbVersionSupport); - this.referencesPath = new ReferencesPath(dbVersionSupport); - this.beaconPath = new BeaconPath(dbVersionSupport); - } - - public ObjectCreator creator() { - return new ObjectCreator(httpClient, config, objectsPath); - } - - public ObjectsGetter objectsGetter() { - return new ObjectsGetter(httpClient, config, objectsPath); - } - - public ObjectsChecker checker() { - return new ObjectsChecker(httpClient, config, objectsPath); - } - - public ObjectDeleter deleter() { - return new ObjectDeleter(httpClient, config, objectsPath); - } - - public ObjectUpdater updater() { - return new ObjectUpdater(httpClient, config, objectsPath); - } - - public ObjectValidator validator() { - return new ObjectValidator(httpClient, config); - } - - public ReferencePayloadBuilder referencePayloadBuilder() { - return new ReferencePayloadBuilder(beaconPath); - } - - public ReferenceCreator referenceCreator() { - return new ReferenceCreator(httpClient, config, referencesPath); - } - - public ReferenceReplacer referenceReplacer() { - return new ReferenceReplacer(httpClient, config, referencesPath); - } - - public ReferenceDeleter referenceDeleter() { - return new ReferenceDeleter(httpClient, config, referencesPath); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectCreator.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectCreator.java deleted file mode 100644 index f5a869b81..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectCreator.java +++ /dev/null @@ -1,99 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import java.util.Map; -import java.util.Objects; -import java.util.UUID; - -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; - -public class ObjectCreator extends BaseClient implements ClientResult { - - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private Map properties; - private Float[] vector; - private Map vectors; - private Map multiVectors; - - public ObjectCreator(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectsPath = Objects.requireNonNull(objectsPath); - } - - public ObjectCreator withID(String id) { - this.id = id; - return this; - } - - public ObjectCreator withClassName(String className) { - this.className = className; - return this; - } - - public ObjectCreator withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectCreator withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectCreator withProperties(Map properties) { - this.properties = properties; - return this; - } - - public ObjectCreator withVector(Float[] vector) { - this.vector = vector; - return this; - } - - public ObjectCreator withVectors(Map vectors) { - this.vectors = vectors; - return this; - } - - public ObjectCreator withMultiVectors(Map multiVectors) { - this.multiVectors = multiVectors; - return this; - } - - private String getID() { - if (StringUtils.isEmpty(id)) { - return UUID.randomUUID().toString(); - } - return id; - } - - @Override - public Result run() { - String path = objectsPath.buildCreate(ObjectsPath.Params.builder() - .consistencyLevel(consistencyLevel) - .build()); - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .vector(vector) - .vectors(vectors) - .multiVectors(multiVectors) - .id(getID()) - .tenant(tenant) - .build(); - Response resp = sendPostRequest(path, obj, WeaviateObject.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectDeleter.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectDeleter.java deleted file mode 100644 index c53f3abe9..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectDeleter.java +++ /dev/null @@ -1,68 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.util.ObjectsPath; -import java.util.Objects; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class ObjectDeleter extends BaseClient implements ClientResult { - - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - - public ObjectDeleter(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectsPath = Objects.requireNonNull(objectsPath); - } - - public ObjectDeleter withID(String id) { - this.id = id; - return this; - } - - public ObjectDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - String path = objectsPath.buildDelete(ObjectsPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .build()); - Response resp = sendDeleteRequest(path, null, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectUpdater.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectUpdater.java deleted file mode 100644 index 9cdb24f12..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectUpdater.java +++ /dev/null @@ -1,115 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import java.util.Map; -import java.util.Objects; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.BooleanUtils; -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; - -public class ObjectUpdater extends BaseClient implements ClientResult { - - private final ObjectsPath objectsPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private Map properties; - private Float[] vector; - private Map vectors; - private Map multiVectors; - private Boolean withMerge; - - public ObjectUpdater(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectsPath = Objects.requireNonNull(objectsPath); - } - - public ObjectUpdater withID(String id) { - this.id = id; - return this; - } - - public ObjectUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ObjectUpdater withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ObjectUpdater withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectUpdater withProperties(Map properties) { - this.properties = properties; - return this; - } - - public ObjectUpdater withVector(Float[] vector) { - this.vector = vector; - return this; - } - - public ObjectUpdater withVectors(Map vectors) { - this.vectors = vectors; - return this; - } - - public ObjectUpdater withMultiVectors(Map multiVectors) { - this.multiVectors = multiVectors; - return this; - } - - public ObjectUpdater withMerge() { - this.withMerge = true; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - String path = objectsPath.buildUpdate(ObjectsPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .build()); - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .id(id) - .vector(vector) - .vectors(vectors) - .multiVectors(multiVectors) - .tenant(tenant) - .build(); - if (BooleanUtils.isTrue(withMerge)) { - Response resp = sendPatchRequest(path, obj, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } - Response resp = sendPutRequest(path, obj, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectValidator.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectValidator.java deleted file mode 100644 index f1e527844..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectValidator.java +++ /dev/null @@ -1,59 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.model.WeaviateObject; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class ObjectValidator extends BaseClient implements ClientResult { - - private String id; - private String className; - private Map properties; - - public ObjectValidator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ObjectValidator withID(String id) { - this.id = id; - return this; - } - - public ObjectValidator withClassName(String className) { - this.className = className; - return this; - } - - public ObjectValidator withProperties(Map properties) { - this.properties = properties; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - WeaviateObject obj = WeaviateObject.builder() - .className(className) - .properties(properties) - .id(id) - .build(); - Response resp = sendPostRequest("/objects/validate", obj, WeaviateObject.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectsChecker.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectsChecker.java deleted file mode 100644 index 76b846bcf..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectsChecker.java +++ /dev/null @@ -1,72 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.util.ObjectsPath; - -import java.util.Collections; -import java.util.Objects; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import org.apache.hc.core5.http.HttpStatus; - -public class ObjectsChecker extends BaseClient implements ClientResult { - - private final ObjectsPath objectsPath; - private String id; - private String className; - private String tenant; - - public ObjectsChecker(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectsPath = Objects.requireNonNull(objectsPath); - } - - public ObjectsChecker withID(String id) { - this.id = id; - return this; - } - - public ObjectsChecker withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsChecker withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(this.id)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("id cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - String path = objectsPath.buildCheck(ObjectsPath.Params.builder() - .id(id) - .className(className) - .tenant(tenant) - .build()); - Response resp = sendHeadRequest(path, String.class); - - switch (resp.getStatusCode()) { - case HttpStatus.SC_NO_CONTENT: - case HttpStatus.SC_NOT_FOUND: - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_NO_CONTENT, resp.getErrors()); - default: - WeaviateErrorResponse dummyError = WeaviateErrorResponse.builder().error(Collections.emptyList()).build(); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_NO_CONTENT, dummyError); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ObjectsGetter.java b/src/main/java/io/weaviate/client/v1/data/api/ObjectsGetter.java deleted file mode 100644 index 4e8d20fef..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ObjectsGetter.java +++ /dev/null @@ -1,139 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Objects; - -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.data.model.ObjectsListResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.util.ObjectsPath; - -public class ObjectsGetter extends BaseClient implements ClientResult> { - - private final ObjectsPath objectsPath; - private String id; - private String className; - private Integer limit; - private Integer offset; - private String after; - private final HashSet additional; - private String consistencyLevel; - private String tenant; - private String nodeName; - - private class ObjectGetter extends BaseClient implements ClientResult> { - private String path; - - public ObjectGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ObjectGetter withPath(String path) { - this.path = path; - return this; - } - - @Override - public Result> run() { - Response resp = sendGetRequest(path, WeaviateObject.class); - WeaviateObject object = resp.getBody(); - List objects = object == null - ? null - : Collections.singletonList(object); - return new Result<>(resp.getStatusCode(), objects, resp.getErrors()); - } - } - - private final ObjectGetter objectGetter; - - public ObjectsGetter(HttpClient httpClient, Config config, ObjectsPath objectsPath) { - super(httpClient, config); - this.objectGetter = new ObjectGetter(httpClient, config); - this.additional = new HashSet<>(); - this.objectsPath = Objects.requireNonNull(objectsPath); - } - - public ObjectsGetter withID(String id) { - this.id = id; - return this; - } - - public ObjectsGetter withClassName(String className) { - this.className = className; - return this; - } - - public ObjectsGetter withLimit(Integer limit) { - this.limit = limit; - return this; - } - - public ObjectsGetter withVector() { - this.additional.add("vector"); - return this; - } - - public ObjectsGetter withAdditional(String name) { - this.additional.add(name); - return this; - } - - public ObjectsGetter withConsistencyLevel(String cl) { - this.consistencyLevel = cl; - return this; - } - - public ObjectsGetter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ObjectsGetter withNodeName(String name) { - this.nodeName = name; - return this; - } - - public ObjectsGetter withAfter(String after) { - this.after = after; - return this; - } - - public ObjectsGetter withOffset(Integer offset) { - this.offset = offset; - return this; - } - - @Override - public Result> run() { - ObjectsPath.Params params = ObjectsPath.Params.builder() - .id(id) - .className(className) - .limit(limit) - .offset(offset) - .after(after) - .additional(additional.toArray(new String[0])) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .nodeName(nodeName) - .build(); - if (StringUtils.isNotBlank(id)) { - return this.objectGetter.withPath(objectsPath.buildGetOne(params)).run(); - } - Response resp = sendGetRequest(objectsPath.buildGet(params), ObjectsListResponse.class); - List objects = resp.getBody() == null - ? null - : Arrays.asList(resp.getBody().getObjects()); - - return new Result<>(resp.getStatusCode(), objects, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ReferenceCreator.java b/src/main/java/io/weaviate/client/v1/data/api/ReferenceCreator.java deleted file mode 100644 index 79758ff1e..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ReferenceCreator.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -import java.util.Objects; - -public class ReferenceCreator extends BaseClient implements ClientResult { - - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef referencePayload; - - public ReferenceCreator(HttpClient httpClient, Config config, ReferencesPath referencesPath) { - super(httpClient, config); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceCreator withID(String id) { - this.id = id; - return this; - } - - public ReferenceCreator withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceCreator withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceCreator withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceCreator withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceCreator withReference(SingleRef referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Result run() { - String path = referencesPath.buildCreate(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - Response resp = sendPostRequest(path, referencePayload, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ReferenceDeleter.java b/src/main/java/io/weaviate/client/v1/data/api/ReferenceDeleter.java deleted file mode 100644 index 5396a4843..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ReferenceDeleter.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -import java.util.Objects; - -public class ReferenceDeleter extends BaseClient implements ClientResult { - - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef referencePayload; - - public ReferenceDeleter(HttpClient httpClient, Config config, ReferencesPath referencesPath) { - super(httpClient, config); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceDeleter withID(String id) { - this.id = id; - return this; - } - - public ReferenceDeleter withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceDeleter withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceDeleter withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceDeleter withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceDeleter withReference(SingleRef referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Result run() { - String path = referencesPath.buildDelete(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - Response resp = sendDeleteRequest(path, referencePayload, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 204, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/api/ReferenceReplacer.java b/src/main/java/io/weaviate/client/v1/data/api/ReferenceReplacer.java deleted file mode 100644 index bcb9face1..000000000 --- a/src/main/java/io/weaviate/client/v1/data/api/ReferenceReplacer.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.v1.data.api; - -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.util.ReferencesPath; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -import java.util.Objects; - -public class ReferenceReplacer extends BaseClient implements ClientResult { - - private final ReferencesPath referencesPath; - private String id; - private String className; - private String consistencyLevel; - private String tenant; - private String referenceProperty; - private SingleRef[] referencePayload; - - public ReferenceReplacer(HttpClient httpClient, Config config, ReferencesPath referencesPath) { - super(httpClient, config); - this.referencesPath = Objects.requireNonNull(referencesPath); - } - - public ReferenceReplacer withID(String id) { - this.id = id; - return this; - } - - public ReferenceReplacer withClassName(String className) { - this.className = className; - return this; - } - - public ReferenceReplacer withConsistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return this; - } - - public ReferenceReplacer withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - public ReferenceReplacer withReferenceProperty(String propertyName) { - this.referenceProperty = propertyName; - return this; - } - - public ReferenceReplacer withReferences(SingleRef... referencePayload) { - this.referencePayload = referencePayload; - return this; - } - - @Override - public Result run() { - String path = referencesPath.buildReplace(ReferencesPath.Params.builder() - .id(id) - .className(className) - .consistencyLevel(consistencyLevel) - .tenant(tenant) - .property(referenceProperty) - .build()); - Response resp = sendPutRequest(path, referencePayload, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilder.java b/src/main/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilder.java deleted file mode 100644 index a72c09074..000000000 --- a/src/main/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilder.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.client.v1.data.builder; - -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.v1.data.model.SingleRef; -import java.util.Objects; - -public class ReferencePayloadBuilder { - - private final BeaconPath beaconPath; - private String id; - private String className; - - @Deprecated - public ReferencePayloadBuilder() { - this.beaconPath = null; - System.err.println("WARNING: Deprecated constructor for ReferencePayloadBuilder class was used. Please use parametrized one."); - } - - public ReferencePayloadBuilder(BeaconPath beaconPath) { - this.beaconPath = Objects.requireNonNull(beaconPath); - } - - public ReferencePayloadBuilder withID(String id) { - this.id = id; - return this; - } - - public ReferencePayloadBuilder withClassName(String className) { - this.className = className; - return this; - } - - public SingleRef payload() { - String beacon; - if (beaconPath != null) { - beacon = beaconPath.buildSingle(BeaconPath.Params.builder() - .id(id) - .className(className) - .build()); - } else { - beacon = beaconDeprecated(); - } - - return SingleRef.builder().beacon(beacon).build(); - } - - private String beaconDeprecated() { - return String.format("weaviate://localhost/%s", id); - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/Deprecation.java b/src/main/java/io/weaviate/client/v1/data/model/Deprecation.java deleted file mode 100644 index bec7fa61c..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/Deprecation.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import java.util.Date; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Deprecation { - String apiType; - String id; - String[] locations; - String mitigation; - String msg; - String plannedRemovalVersion; - String removedIn; - Date removedTime; - Date sinceTime; - String sinceVersion; - String status; -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/ObjectReference.java b/src/main/java/io/weaviate/client/v1/data/model/ObjectReference.java deleted file mode 100644 index 0328d1b03..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/ObjectReference.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ObjectReference { - String beacon; -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/ObjectsListResponse.java b/src/main/java/io/weaviate/client/v1/data/model/ObjectsListResponse.java deleted file mode 100644 index 6a56bc7ad..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/ObjectsListResponse.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ObjectsListResponse { - Deprecation[] deprecations; - WeaviateObject[] objects; - int totalResults; -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/ReferenceMetaClassification.java b/src/main/java/io/weaviate/client/v1/data/model/ReferenceMetaClassification.java deleted file mode 100644 index 0a4f9f4b5..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/ReferenceMetaClassification.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ReferenceMetaClassification { - Double closestLosingDistance; - Double closestOverallDistance; - Double closestWinningDistance; - Long losingCount; - Double losingDistance; - Double meanLosingDistance; - Double meanWinningDistance; - Long overallCount; - Long winningCount; - Double winningDistance; -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/SingleRef.java b/src/main/java/io/weaviate/client/v1/data/model/SingleRef.java deleted file mode 100644 index b42c1d2e9..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/SingleRef.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import com.google.gson.annotations.SerializedName; -import java.util.Map; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class SingleRef { - @SerializedName("class") - String clazz; - String beacon; - ReferenceMetaClassification classification; - String href; - Map schema; -} diff --git a/src/main/java/io/weaviate/client/v1/data/model/WeaviateObject.java b/src/main/java/io/weaviate/client/v1/data/model/WeaviateObject.java deleted file mode 100644 index a0721cab5..000000000 --- a/src/main/java/io/weaviate/client/v1/data/model/WeaviateObject.java +++ /dev/null @@ -1,138 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import java.lang.reflect.Type; -import java.util.HashMap; -import java.util.Map; -import java.util.Map.Entry; - -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.JsonArray; -import com.google.gson.JsonDeserializationContext; -import com.google.gson.JsonDeserializer; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParseException; -import com.google.gson.JsonSerializationContext; -import com.google.gson.JsonSerializer; -import com.google.gson.TypeAdapterFactory; -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Setter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class WeaviateObject { - String id; - @SerializedName("class") - String className; - Long creationTimeUnix; - Long lastUpdateTimeUnix; - Map properties; - Map additional; - - /** - * Unnamed (default) vector. - *

- * This field will be deprecated in later versions. - * Prefer using {@link #vectors} for collections storing a single vector only. - */ - Float[] vector; - - /** Named vectors. */ - @Builder.Default - Map vectors = new HashMap<>(); - - /** Named multivectors. */ - @Builder.Default - transient Map multiVectors = new HashMap<>(); - Object vectorWeights; - String tenant; - - public static class Adapter implements JsonSerializer, JsonDeserializer { - public static final Adapter INSTANCE = new Adapter(); - - /** - * This Gson instance does not have the {@link Adapter} registerred allowing us - * to deserialize remaining {@link WeaviateObject} fields in a standard manner - * without causing an infinite recursion. - * - * Mimicking {@link Serializer}, we disable HTML escaping to produce identical - * results. Thankfully, its configuration is not too involved, so we can - * tolerate this duplication. In the future, {@link Adapter} should be rewritten - * to implement {@link TypeAdapterFactory}, so that the singleton instance can - * be re-used in this context too. - */ - private static final Gson gson = new GsonBuilder().disableHtmlEscaping().create(); - - @Override - public JsonElement serialize(WeaviateObject src, Type typeOfSrc, JsonSerializationContext ctx) { - JsonObject result = gson.toJsonTree(src).getAsJsonObject(); - - if (result.has("vectors") && result.getAsJsonObject("vectors").isEmpty()) { - result.remove("vectors"); - } - - // Add multi-vectors to the named vectors map. - if (src.multiVectors != null && !src.multiVectors.isEmpty()) { - if (!result.has("vectors")) { - result.add("vectors", new JsonObject()); - } - JsonObject vectors = result.getAsJsonObject("vectors"); - - for (Entry entry : src.multiVectors.entrySet()) { - String name = entry.getKey(); - JsonElement vector = gson.toJsonTree(entry.getValue()); - vectors.add(name, vector); - } - } - return result; - } - - @Override - public WeaviateObject deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) - throws JsonParseException { - JsonObject jsonObject = json.getAsJsonObject(); - - // Handle polymorphic "vectors" separately from the rest of the fields. - Map vectorsMap = new HashMap<>(); - if (jsonObject.has("vectors")) { - vectorsMap = jsonObject.remove("vectors").getAsJsonObject().asMap(); - } - WeaviateObject result = gson.fromJson(jsonObject, WeaviateObject.class); - - if (result.vectors == null) { - result.vectors = new HashMap<>(); - } - if (result.multiVectors == null) { - result.multiVectors = new HashMap<>(); - } - - for (Entry entry : vectorsMap.entrySet()) { - String name = entry.getKey(); - JsonElement el = entry.getValue(); - if (el.isJsonArray()) { - JsonArray array = el.getAsJsonArray(); - if (array.size() > 0 && array.get(0).isJsonArray()) { - result.multiVectors.put(name, ctx.deserialize(array, Float[][].class)); - } else { - result.vectors.put(name, ctx.deserialize(array, Float[].class)); - } - } - } - - return result; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/replication/model/ConsistencyLevel.java b/src/main/java/io/weaviate/client/v1/data/replication/model/ConsistencyLevel.java deleted file mode 100644 index 476d43f3e..000000000 --- a/src/main/java/io/weaviate/client/v1/data/replication/model/ConsistencyLevel.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.client.v1.data.replication.model; - -public interface ConsistencyLevel { - String ALL = "ALL"; - String ONE = "ONE"; - String QUORUM = "QUORUM"; -} diff --git a/src/main/java/io/weaviate/client/v1/data/util/ObjectsPath.java b/src/main/java/io/weaviate/client/v1/data/util/ObjectsPath.java deleted file mode 100644 index 9ddefe957..000000000 --- a/src/main/java/io/weaviate/client/v1/data/util/ObjectsPath.java +++ /dev/null @@ -1,211 +0,0 @@ -package io.weaviate.client.v1.data.util; - -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.TriConsumer; -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.commons.lang3.StringUtils; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.stream.Collectors; - -public class ObjectsPath { - - private final DbVersionSupport support; - - public ObjectsPath(DbVersionSupport support) { - this.support = support; - } - - - public String buildCreate(Params params) { - return build( - params, - this::addQueryConsistencyLevel - ); - } - - public String buildDelete(Params params) { - return build( - params, - this::addPathClassNameWithDeprecatedNotSupportedCheck, - this::addPathId, - this::addQueryConsistencyLevel, - this::addQueryTenant - ); - } - - public String buildUpdate(Params params) { - return build( - params, - this::addPathClassNameWithDeprecatedCheck, - this::addPathId, - this::addQueryConsistencyLevel, - this::addQueryTenant - ); - } - - public String buildCheck(Params params) { - return build( - params, - this::addPathClassNameWithDeprecatedNotSupportedCheck, - this::addPathId, - this::addQueryTenant - ); - } - - public String buildGet(Params params) { - return build( - params, - this::addQueryClassNameWithDeprecatedCheck, - this::addQueryAdditionals, - this::addQueryLimit, - this::addQueryOffset, - this::addQueryAfter, - this::addQueryTenant - ); - } - - public String buildGetOne(Params params) { - return build( - params, - this::addPathClassNameWithDeprecatedNotSupportedCheck, - this::addPathId, - this::addQueryAdditionals, - this::addQueryConsistencyLevel, - this::addQueryNodeName, - this::addQueryTenant - ); - } - - - @SafeVarargs - private final String build(Params params, TriConsumer, List>... appenders) { - Objects.requireNonNull(params); - - List pathParams = new ArrayList<>(); - List queryParams = new ArrayList<>(); - - pathParams.add("/objects"); - Arrays.stream(appenders).forEach(consumer -> consumer.accept(params, pathParams, queryParams)); - - String path = String.join("/", pathParams); - if (!queryParams.isEmpty()) { - return path + "?" + String.join("&", queryParams); - } - return path; - } - - - private void addPathClassNameWithDeprecatedNotSupportedCheck(Params params, List pathParams, List queryParams) { - if (support.supportsClassNameNamespacedEndpoints()) { - if (StringUtils.isNotBlank(params.className)) { - pathParams.add(UrlEncoder.encodePathParam(params.className)); - } else { - support.warnDeprecatedNonClassNameNamespacedEndpointsForObjects(); - } - } else if (StringUtils.isNotBlank(params.className)) { - support.warnNotSupportedClassNamespacedEndpointsForObjects(); - } - } - - private void addPathClassNameWithDeprecatedCheck(Params params, List pathParams, List queryParams) { - if (support.supportsClassNameNamespacedEndpoints()) { - if (StringUtils.isNotBlank(params.className)) { - pathParams.add(UrlEncoder.encodePathParam(params.className)); - } else { - support.warnDeprecatedNonClassNameNamespacedEndpointsForObjects(); - } - } - } - - private void addPathId(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.id)) { - pathParams.add(UrlEncoder.encodePathParam(params.id)); - } - } - - - private void addQueryClassNameWithDeprecatedCheck(Params params, List pathParams, List queryParams) { - if (StringUtils.isBlank(params.id) && StringUtils.isNotBlank(params.className)) { - if (support.supportsClassNameNamespacedEndpoints()) { - queryParams.add(UrlEncoder.encodeQueryParam("class", params.className)); - } else { - support.warnNotSupportedClassParameterInEndpointsForObjects(); - } - } - } - - private void addQueryAdditionals(Params params, List pathParams, List queryParams) { - if (ObjectUtils.isNotEmpty(params.additional)) { - String include = Arrays.stream(params.additional) - .map(UrlEncoder::encodePathParam) - .filter(StringUtils::isNotBlank) - .collect(Collectors.joining(",")); - - if (StringUtils.isNotBlank(include)) { - queryParams.add(String.format("%s=%s", "include", include)); - } - } - } - - private void addQueryLimit(Params params, List pathParams, List queryParams) { - if (params.limit != null) { - queryParams.add(UrlEncoder.encodeQueryParam("limit", Integer.toString(params.limit))); - } - } - - private void addQueryOffset(Params params, List pathParams, List queryParams) { - if (params.offset != null) { - queryParams.add(UrlEncoder.encodeQueryParam("offset", Integer.toString(params.offset))); - } - } - - private void addQueryAfter(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.after)) { - queryParams.add(UrlEncoder.encodeQueryParam("after", params.after)); - } - } - - private void addQueryConsistencyLevel(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.consistencyLevel)) { - queryParams.add(UrlEncoder.encodeQueryParam("consistency_level", params.consistencyLevel)); - } - } - - private void addQueryNodeName(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.nodeName)) { - queryParams.add(UrlEncoder.encodeQueryParam("node_name", params.nodeName)); - } - } - - private void addQueryTenant(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.tenant)) { - queryParams.add(UrlEncoder.encodeQueryParam("tenant", params.tenant)); - } - } - - - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Params { - - String id; - String className; - Integer limit; - Integer offset; - String after; - String[] additional; - String consistencyLevel; - String nodeName; - String tenant; - } -} diff --git a/src/main/java/io/weaviate/client/v1/data/util/ReferencesPath.java b/src/main/java/io/weaviate/client/v1/data/util/ReferencesPath.java deleted file mode 100644 index ad16eea63..000000000 --- a/src/main/java/io/weaviate/client/v1/data/util/ReferencesPath.java +++ /dev/null @@ -1,122 +0,0 @@ -package io.weaviate.client.v1.data.util; - -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.TriConsumer; -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; - -public class ReferencesPath { - - private final DbVersionSupport support; - - public ReferencesPath(DbVersionSupport support) { - this.support = support; - } - - - public String buildCreate(Params params) { - return commonBuild(params); - } - - public String buildDelete(Params params) { - return commonBuild(params); - } - - public String buildReplace(Params params) { - return commonBuild(params); - } - - private String commonBuild(Params params) { - return build( - params, - this::addPathClassNameWithDeprecatedNotSupportedCheck, - this::addPathId, - this::addPathReferences, - this::addPathProperty, - this::addQueryConsistencyLevel, - this::addQueryTenant - ); - } - - - @SafeVarargs - private final String build(Params params, TriConsumer, List>... appenders) { - Objects.requireNonNull(params); - - List pathParams = new ArrayList<>(); - List queryParams = new ArrayList<>(); - - pathParams.add("/objects"); - Arrays.stream(appenders).forEach(consumer -> consumer.accept(params, pathParams, queryParams)); - - String path = String.join("/", pathParams); - if (!queryParams.isEmpty()) { - return path + "?" + String.join("&", queryParams); - } - return path; - } - - - private void addPathClassNameWithDeprecatedNotSupportedCheck(Params params, List pathParams, List queryParams) { - if (support.supportsClassNameNamespacedEndpoints()) { - if (StringUtils.isNotBlank(params.className)) { - pathParams.add(UrlEncoder.encodePathParam(params.className)); - } else { - support.warnDeprecatedNonClassNameNamespacedEndpointsForObjects(); - } - } else if (StringUtils.isNotBlank(params.className)) { - support.warnNotSupportedClassNamespacedEndpointsForObjects(); - } - } - - private void addPathId(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.id)) { - pathParams.add(UrlEncoder.encodePathParam(params.id)); - } - } - - private void addPathReferences(Params params, List pathParams, List queryParams) { - pathParams.add("references"); - } - - private void addPathProperty(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.property)) { - pathParams.add(UrlEncoder.encodePathParam(params.property)); - } - } - - - private void addQueryConsistencyLevel(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.consistencyLevel)) { - queryParams.add(UrlEncoder.encodeQueryParam("consistency_level", params.consistencyLevel)); - } - } - - private void addQueryTenant(Params params, List pathParams, List queryParams) { - if (StringUtils.isNotBlank(params.tenant)) { - queryParams.add(UrlEncoder.encodeQueryParam("tenant", params.tenant)); - } - } - - - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Params { - - String id; - String className; - String consistencyLevel; - String tenant; - String property; - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Batcher.java b/src/main/java/io/weaviate/client/v1/experimental/Batcher.java deleted file mode 100644 index 322b77ecb..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Batcher.java +++ /dev/null @@ -1,111 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Consumer; - -import org.apache.commons.lang3.time.DateFormatUtils; - -import io.weaviate.client.Config; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.batch.Batch; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.Data; -import io.weaviate.client.v1.data.model.WeaviateObject; -import lombok.AllArgsConstructor; - -public class Batcher implements AutoCloseable { - private final Class cls; - private final ObjectsBatcher objectsBatcher; - - public Batcher(Config config, HttpClient httpClient, AccessTokenProvider tokenProvider, DbVersionSupport dbVersion, - GrpcVersionSupport grpcVersion, Data data, Class cls) { - this.cls = cls; - this.objectsBatcher = new Batch(httpClient, config, dbVersion, grpcVersion, tokenProvider, data).objectsBatcher(); - } - - public boolean insert(Consumer> data) { - InsertBatch batch = new InsertBatch<>(cls, data); - batch.append(objectsBatcher); - - final Result result = objectsBatcher.run(); - return !result.hasErrors(); - } - - @Override - public void close() { - this.objectsBatcher.close(); - } - - public static class InsertBatch { - private final Class cls; - private final List<$WeaviateObject> objects = new ArrayList<>(); - - public void add(T properties) { - add(properties, null, null); - } - - public void add(T properties, String id) { - add(properties, id, null); - } - - public void add(T properties, Float[] vector) { - add(properties, null, vector); - } - - public void add(T properties, String id, Float[] vector) { - objects.add(new $WeaviateObject(id, vector, properties)); - } - - InsertBatch(Class cls, Consumer> populate) { - this.cls = cls; - populate.accept(this); - } - - void append(ObjectsBatcher batcher) { - for ($WeaviateObject object : objects) { - batcher.withObject(WeaviateObject.builder() - .className(cls.getSimpleName() + "s") - .vector(object.vector) - .properties(toMap(object.properties)) - .id(object.id) - .build()); - } - } - - private Map toMap(T properties) { - Map fieldMap = new HashMap<>(); - for (Field field : cls.getDeclaredFields()) { - field.setAccessible(true); - try { - Object value = field.get(properties); - // TODO: there will need to be a more delicate way of handling these things - // but this will suffice to demostrate the idea. - if (value instanceof Date) { - value = DateFormatUtils.format((Date) value, "yyyy-MM-dd'T'HH:mm:ssZZZZZ"); - } - fieldMap.put(field.getName(), value); - } catch (IllegalAccessException e) { - // Ignore for now - } - } - return fieldMap; - } - - @AllArgsConstructor - private static class $WeaviateObject { - final String id; - final Float[] vector; - final T properties; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Collection.java b/src/main/java/io/weaviate/client/v1/experimental/Collection.java deleted file mode 100644 index 957a77e29..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Collection.java +++ /dev/null @@ -1,12 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; - -public class Collection { - public final SearchClient query; - - Collection(Config config, AccessTokenProvider tokenProvider, String collection, Class cls) { - this.query = new SearchClient(config, tokenProvider, collection, cls); - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Collections.java b/src/main/java/io/weaviate/client/v1/experimental/Collections.java deleted file mode 100644 index 7c4a0c8c6..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Collections.java +++ /dev/null @@ -1,15 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Collections { - private final Config config; - private final AccessTokenProvider tokenProvider; - - public Collection use(String collection, Class cls) { - return new Collection(config, tokenProvider, collection, cls); - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/DataClient.java b/src/main/java/io/weaviate/client/v1/experimental/DataClient.java deleted file mode 100644 index 2483101a4..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/DataClient.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.GrpcVersionSupport; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.data.Data; -import lombok.RequiredArgsConstructor; - -/** DataClient handles insertions, updates, and deletes, as well as batching. */ -@RequiredArgsConstructor -public class DataClient { - private final Config config; - private final HttpClient httpClient; - private final AccessTokenProvider tokenProvider; - private final DbVersionSupport dbVersion; - private final GrpcVersionSupport grpcVersion; - private final Data data; - - public Batcher batch(Class cls) { - return new Batcher<>(config, httpClient, tokenProvider, dbVersion, grpcVersion, data, cls); - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Metadata.java b/src/main/java/io/weaviate/client/v1/experimental/Metadata.java deleted file mode 100644 index 148e73fe1..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Metadata.java +++ /dev/null @@ -1,12 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest; - -/** - * Metadata is the common base for all properties that are requestes as - * "_additional". It is an inteface all metadata properties MUST implement to be - * used in {@link SearchOptions}. - */ -public interface Metadata { - void append(MetadataRequest.Builder metadata); -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/MetadataField.java b/src/main/java/io/weaviate/client/v1/experimental/MetadataField.java deleted file mode 100644 index 1df3ff523..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/MetadataField.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest; - -/** - * MetadataField are collection properties that can be requested for any object. - */ -public enum MetadataField implements Metadata { - ID("id"), - VECTOR("vector"), - DISTANCE("distance"); - - private final String name; - - private MetadataField(String name) { - this.name = name; - } - - // FIXME: ideally, we don't want to surface this method in the public API - public void append(MetadataRequest.Builder metadata) { - switch (this.name) { - case "id": - metadata.setUuid(true); - break; - case "vector": - metadata.setVector(true); - break; - case "distance": - metadata.setDistance(true); - break; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/NearVector.java b/src/main/java/io/weaviate/client/v1/experimental/NearVector.java deleted file mode 100644 index ece84e681..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/NearVector.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.util.function.Consumer; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest; -import io.weaviate.client.v1.grpc.GRPC; - -public class NearVector { - private final float[] vector; - private final Options opt; - - void append(SearchRequest.Builder search) { - WeaviateProtoBaseSearch.NearVector.Builder nearVector = WeaviateProtoBaseSearch.NearVector - .newBuilder(); - nearVector.setVectorBytes(GRPC.toByteString(vector)); - opt.append(search, nearVector); - search.setNearVector(nearVector.build()); - } - - public NearVector(float[] vector, Consumer options) { - this.opt = new Options(); - this.vector = vector; - options.accept(this.opt); - } - - public static class Options extends SearchOptions { - private Float distance; - private Float certainty; - - public Options distance(float distance) { - this.distance = distance; - return this; - } - - public Options certainty(float certainty) { - this.certainty = certainty; - return this; - } - - void append(SearchRequest.Builder search, WeaviateProtoBaseSearch.NearVector.Builder nearVector) { - if (certainty != null) { - nearVector.setCertainty(certainty); - } else if (distance != null) { - nearVector.setDistance(distance); - } - super.append(search); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Operand.java b/src/main/java/io/weaviate/client/v1/experimental/Operand.java deleted file mode 100644 index 7e7418b28..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Operand.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters; - -public interface Operand { - void append(Filters.Builder where); -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/SearchClient.java b/src/main/java/io/weaviate/client/v1/experimental/SearchClient.java deleted file mode 100644 index f023ece71..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/SearchClient.java +++ /dev/null @@ -1,184 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.time.OffsetDateTime; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Consumer; -import java.util.stream.Collectors; - -import com.google.gson.Gson; -import com.google.gson.JsonElement; - -import io.weaviate.client.Config; -import io.weaviate.client.base.grpc.GrpcClient; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoProperties.Value; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataResult; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.experimental.NearVector.Options; -import io.weaviate.client.v1.grpc.GRPC; - -public class SearchClient { - private final AccessTokenProvider tokenProvider; - private final Config config; - private final String collection; - private final Gson gson; - - // We won't be able to get away with doing reflection with the type variable, - // because it is erased at compilation. Gson works around that by introducing - // their own TypeToken, from which annonymous subclasses can be created at - // runtime. - // Those retain information about generic type: - // https://github.com/google/gson/blob/528fd3195bad9c6c816e77c96750b3188a514365/gson/src/main/java/com/google/gson/reflect/TypeToken.java#L40-L44 - // Most likely we won't need any such machinery, because users' models will - // probably be POJOs rathen than List>. - private final Class cls; - - public SearchResult> nearVectorUntyped(float[] vector) { - return nearVectorUntyped(vector, nop -> { - }); - } - - public SearchResult> nearVectorUntyped(float[] vector, Consumer options) { - NearVector operator = new NearVector(vector, options); - SearchRequest.Builder req = SearchRequest.newBuilder(); - req.setCollection(collection); - req.setUses123Api(true); - req.setUses125Api(true); - req.setUses127Api(true); - operator.append(req); - return searchUntyped(req.build()); - } - - private SearchResult> searchUntyped(SearchRequest req) { - GrpcClient grpc = GrpcClient.create(config, tokenProvider); - try { - return deserializeUntyped(grpc.search(req)); - } finally { - grpc.shutdown(); - } - } - - public static SearchResult> deserializeUntyped(SearchReply reply) { - List>> objects = reply.getResultsList().stream() - .map(res -> { - Map properties = convertProtoMap(res.getProperties().getNonRefProps().getFieldsMap()); - - MetadataResult meta = res.getMetadata(); - SearchResult.SearchObject.SearchMetadata metadata = new SearchResult.SearchObject.SearchMetadata( - meta.getId(), - meta.getDistancePresent() ? meta.getDistance() : null, - GRPC.fromByteString(meta.getVectorBytes())); - - return new SearchResult.SearchObject>(properties, metadata); - }).collect(Collectors.toList()); - - return new SearchResult>(objects); - } - - public SearchResult nearVector(float[] vector) { - return nearVector(vector, nop -> { - }); - } - - public SearchResult nearVector(float[] vector, Consumer options) { - NearVector operator = new NearVector(vector, options); - SearchRequest.Builder req = SearchRequest.newBuilder(); - req.setCollection(collection); - req.setUses123Api(true); - req.setUses125Api(true); - req.setUses127Api(true); - operator.append(req); - return search(req.build()); - } - - private SearchResult search(SearchRequest req) { - GrpcClient grpc = GrpcClient.create(config, tokenProvider); - try { - return deserialize(grpc.search(req)); - } finally { - grpc.shutdown(); - } - } - - /** - * deserialize offers a naive ORM implementation. It extracts properties map for - * each result object and creates an instance of type T from it using - * {@code Gson} as a reflection-based mapper. - * - *

- * This incurrs an overhead of creating an intermediate JSON representation of - * the property map, which is necessary to use {@link Gson}'s reflection. This - * will suffice for a POC, but will be replaced by our own reflection module - * before a productive release. - */ - private SearchResult deserialize(SearchReply reply) { - List> objects = reply.getResultsList().stream() - .map(res -> { - Map propertiesMap = convertProtoMap(res.getProperties().getNonRefProps().getFieldsMap()); - JsonElement el = gson.toJsonTree(propertiesMap); - T properties = gson.fromJson(el, cls); - - MetadataResult meta = res.getMetadata(); - SearchResult.SearchObject.SearchMetadata metadata = new SearchResult.SearchObject.SearchMetadata( - meta.getId(), - meta.getDistancePresent() ? meta.getDistance() : null, - GRPC.fromByteString(meta.getVectorBytes())); - - return new SearchResult.SearchObject(properties, metadata); - }).collect(Collectors.toList()); - - return new SearchResult(objects); - } - - /** - * Convert Map to Map such that can be - * (de-)serialized by {@link Gson}. - */ - private static Map convertProtoMap(Map map) { - return map.entrySet().stream() - // We cannot use Collectors.toMap() here, because convertProtoValue may - // return null (a collection property can be null), which breaks toMap(). - // See: https://bugs.openjdk.org/browse/JDK-8148463 - .collect( - HashMap::new, - (m, e) -> m.put(e.getKey(), convertProtoValue(e.getValue())), - HashMap::putAll); - } - - /** - * Convert protobuf's Value stub to an Object by extracting the first available - * field. The checks are non-exhaustive and only cover text, boolean, and - * integer values. - */ - private static Object convertProtoValue(Value value) { - if (value.hasTextValue()) { - return value.getTextValue(); - } else if (value.hasBoolValue()) { - return value.getBoolValue(); - } else if (value.hasIntValue()) { - return value.getIntValue(); - } else if (value.hasNumberValue()) { - return value.getNumberValue(); - } else if (value.hasDateValue()) { - OffsetDateTime offsetDateTime = OffsetDateTime.parse(value.getDateValue()); - return Date.from(offsetDateTime.toInstant()); - } else if (value.hasNullValue()) { - return null; - } else { - assert false : "branch not covered"; - } - return null; - } - - SearchClient(Config config, AccessTokenProvider tokenProvider, String collection, Class cls) { - this.config = config; - this.tokenProvider = tokenProvider; - this.collection = collection; - this.gson = new Gson(); - this.cls = cls; - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/SearchOptions.java b/src/main/java/io/weaviate/client/v1/experimental/SearchOptions.java deleted file mode 100644 index 68f62868b..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/SearchOptions.java +++ /dev/null @@ -1,104 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest; - -@SuppressWarnings("unchecked") -public abstract class SearchOptions> { - private Integer limit; - private Integer offset; - private Integer autocut; - private String after; - private String consistencyLevel; - private Where where; - private List returnProperties = new ArrayList<>(); - private List returnMetadata = new ArrayList<>(); - - void append(SearchRequest.Builder search) { - if (limit != null) { - search.setLimit(limit); - } - if (offset != null) { - search.setOffset(offset); - } - if (StringUtils.isNotBlank(after)) { - search.setAfter(after); - } - if (StringUtils.isNotBlank(consistencyLevel)) { - search.setConsistencyLevelValue(Integer.valueOf(consistencyLevel)); - } - if (autocut != null) { - search.setAutocut(autocut); - } - - if (where != null && !where.isEmpty()) { - Filters.Builder filters = Filters.newBuilder(); - where.append(filters); - search.setFilters(filters); - } - - if (!returnMetadata.isEmpty()) { - MetadataRequest.Builder metadata = MetadataRequest.newBuilder(); - returnMetadata.forEach(m -> m.append(metadata)); - search.setMetadata(metadata); - } - - if (!returnProperties.isEmpty()) { - PropertiesRequest.Builder properties = PropertiesRequest.newBuilder(); - for (String property : returnProperties) { - properties.addNonRefProperties(property); - } - search.setProperties(properties); - } - } - - public final SELF limit(Integer limit) { - this.limit = limit; - return (SELF) this; - } - - public final SELF offset(Integer offset) { - this.offset = offset; - return (SELF) this; - } - - public final SELF autocut(Integer autocut) { - this.autocut = autocut; - return (SELF) this; - } - - public final SELF after(String after) { - this.after = after; - return (SELF) this; - } - - public final SELF consistencyLevel(String consistencyLevel) { - this.consistencyLevel = consistencyLevel; - return (SELF) this; - } - - public final SELF where(Where where) { - this.where = where; - return (SELF) this; - } - - @SafeVarargs - public final SELF returnProperties(String... properties) { - this.returnProperties = Arrays.asList(properties); - return (SELF) this; - } - - @SafeVarargs - public final SELF returnMetadata(Metadata... metadata) { - this.returnMetadata = Arrays.asList(metadata); - return (SELF) this; - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/SearchResult.java b/src/main/java/io/weaviate/client/v1/experimental/SearchResult.java deleted file mode 100644 index dddc40c86..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/SearchResult.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.util.List; - -import lombok.AllArgsConstructor; -import lombok.ToString; - -@AllArgsConstructor -public class SearchResult { - public final List> objects; - - @AllArgsConstructor - public static class SearchObject { - public final T properties; - public final SearchMetadata metadata; - - @AllArgsConstructor - @ToString - public static class SearchMetadata { - public final String id; - public final Float distance; - public final Float[] vector; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/experimental/Where.java b/src/main/java/io/weaviate/client/v1/experimental/Where.java deleted file mode 100644 index 74bb7bdbe..000000000 --- a/src/main/java/io/weaviate/client/v1/experimental/Where.java +++ /dev/null @@ -1,720 +0,0 @@ -package io.weaviate.client.v1.experimental; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Date; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -import org.apache.commons.lang3.time.DateFormatUtils; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters; -import lombok.RequiredArgsConstructor; - -public class Where implements Operand { - - @RequiredArgsConstructor - public enum Operator { - // Logical operators - AND("And", Filters.Operator.OPERATOR_AND), - OR("Or", Filters.Operator.OPERATOR_OR), - - // Comparison operators - EQUAL("Equal", Filters.Operator.OPERATOR_EQUAL), - NOT_EQUAL("NotEqual", Filters.Operator.OPERATOR_NOT_EQUAL), - LESS_THAN("LessThen", Filters.Operator.OPERATOR_LESS_THAN), - LESS_THAN_EQUAL("LessThenEqual", Filters.Operator.OPERATOR_LESS_THAN_EQUAL), - GREATER_THAN("GreaterThen", Filters.Operator.OPERATOR_GREATER_THAN), - GREATER_THAN_EQUAL("GreaterThenEqual", Filters.Operator.OPERATOR_GREATER_THAN_EQUAL), - LIKE("Like", Filters.Operator.OPERATOR_LIKE), - CONTAINS_ANY("ContainsAny", Filters.Operator.OPERATOR_CONTAINS_ANY), - CONTAINS_ALL("ContainsAll", Filters.Operator.OPERATOR_CONTAINS_ALL), - WITHIN_GEO_RANGE("WithinGeoRange", Filters.Operator.OPERATOR_WITHIN_GEO_RANGE); - - /** String representation for better debug logs. */ - private final String string; - - /** gRPC operator value . */ - private final Filters.Operator grpc; - - public void append(Filters.Builder where) { - where.setOperator(grpc); - } - - public String toString() { - return string; - } - } - - private final Operator operator; - private List operands = new ArrayList<>(); - - public boolean isEmpty() { - // TODO: if operands not empty, we need to check that each operand is not empty - // either. Guard against Where.and(Where.or(), Where.and()) situation. - return operands.isEmpty(); - } - - @SafeVarargs - private Where(Operator operator, Operand... operands) { - this(operator, Arrays.asList(operands)); - } - - private Where(Operator operator, List operands) { - this.operator = operator; - this.operands = operands; - } - - // Logical operators return a complete operand. - // -------------------------------------------- - public static Where and(Operand... operands) { - return new Where(Operator.AND, operands); - } - - public static Where and(Map filters, Operator operator) { - return new Where(Operator.AND, fromMap(filters, operator)); - } - - public static Where or(Operand... operands) { - return new Where(Operator.OR, operands); - } - - public static Where or(Map filters, Operator operator) { - return new Where(Operator.OR, fromMap(filters, operator)); - } - - public static List fromMap(Map filters, Operator operator) { - if (operator.equals(Operator.AND) || operator.equals(Operator.OR)) { - // TODO: we will avoid this by not exposing AND/OR operators to the user. - throw new IllegalArgumentException("AND/OR operators are not comparison operators"); - } - return filters.entrySet().stream() - .map(entry -> new Where( - operator, - new Path(entry.getKey()), - ComparisonBuilder.fromObject(entry.getValue()))) - .collect(Collectors.toList()); - } - - // Comparison operators return fluid builder. - // ------------------------------------------ - - public static ComparisonBuilder property(String property) { - return new ComparisonBuilder(new Path(property)); - } - - public static ComparisonBuilder reference(String... path) { - return new ComparisonBuilder(new Path(path)); - } - - public static class ComparisonBuilder { - private Operand left; - - private ComparisonBuilder(Operand left) { - this.left = left; - } - - @SuppressWarnings("unchecked") - static Operand fromObject(Object value) { - if (value instanceof String) { - return new $Text((String) value); - } else if (value instanceof Boolean) { - return new $Boolean((Boolean) value); - } else if (value instanceof Integer) { - return new $Integer((Integer) value); - } else if (value instanceof Number) { - return new $Number((Number) value); - } else if (value instanceof Date) { - return new $Date((Date) value); - } else if (value instanceof String[]) { - return new $TextArray((String[]) value); - } else if (value instanceof Boolean[]) { - return new $BooleanArray((Boolean[]) value); - } else if (value instanceof Integer[]) { - return new $IntegerArray((Integer[]) value); - } else if (value instanceof Number[]) { - return new $NumberArray((Number[]) value); - } else if (value instanceof Date[]) { - return new $DateArray((Date[]) value); - } else if (value instanceof List) { - if (((List) value).isEmpty()) { - throw new IllegalArgumentException( - "Filter with non-reifiable type (List) cannot be empty, use an array instead"); - } - - Object first = ((List) value).get(0); - if (first instanceof String) { - return new $TextArray((List) value); - } else if (first instanceof Boolean) { - return new $BooleanArray((List) value); - } else if (first instanceof Integer) { - return new $IntegerArray((List) value); - } else if (first instanceof Number) { - return new $NumberArray((List) value); - } else if (first instanceof Date) { - return new $DateArray((List) value); - } - } - throw new IllegalArgumentException( - "value must be either of String, Boolean, Date, Integer, Number, Array/List of these types"); - } - - // Equal - // ------------------------------------------ - public Where eq(String value) { - return new Where(Operator.EQUAL, left, new $Text(value)); - } - - public Where eq(String... values) { - return new Where(Operator.EQUAL, left, new $TextArray(values)); - } - - public Where eq(Boolean value) { - return new Where(Operator.EQUAL, left, new $Boolean(value)); - } - - public Where eq(Boolean... values) { - return new Where(Operator.EQUAL, left, new $BooleanArray(values)); - } - - public Where eq(Integer value) { - return new Where(Operator.EQUAL, left, new $Integer(value)); - } - - public Where eq(Integer... values) { - return new Where(Operator.EQUAL, left, new $IntegerArray(values)); - } - - public Where eq(Number value) { - return new Where(Operator.EQUAL, left, new $Number(value.doubleValue())); - } - - public Where eq(Number... values) { - return new Where(Operator.EQUAL, left, new $NumberArray(values)); - } - - public Where eq(Date value) { - return new Where(Operator.EQUAL, left, new $Date(value)); - } - - public Where eq(Date... values) { - return new Where(Operator.EQUAL, left, new $DateArray(values)); - } - - public Where eq(Object value) { - return new Where(Operator.EQUAL, left, fromObject(value)); - } - - // NotEqual - // ------------------------------------------ - public Where ne(String value) { - return new Where(Operator.NOT_EQUAL, left, new $Text(value)); - } - - public Where ne(String... values) { - return new Where(Operator.NOT_EQUAL, left, new $TextArray(values)); - } - - public Where ne(Boolean value) { - return new Where(Operator.NOT_EQUAL, left, new $Boolean(value)); - } - - public Where ne(Boolean... values) { - return new Where(Operator.NOT_EQUAL, left, new $BooleanArray(values)); - } - - public Where ne(Integer value) { - return new Where(Operator.NOT_EQUAL, left, new $Integer(value)); - } - - public Where ne(Integer... values) { - return new Where(Operator.NOT_EQUAL, left, new $IntegerArray(values)); - } - - public Where ne(Number value) { - return new Where(Operator.NOT_EQUAL, left, new $Number(value.doubleValue())); - } - - public Where ne(Number... values) { - return new Where(Operator.NOT_EQUAL, left, new $NumberArray(values)); - } - - public Where ne(Date value) { - return new Where(Operator.NOT_EQUAL, left, new $Date(value)); - } - - public Where ne(Date... values) { - return new Where(Operator.NOT_EQUAL, left, new $DateArray(values)); - } - - // LessThan - // ------------------------------------------ - public Where lt(String value) { - return new Where(Operator.LESS_THAN, left, new $Text(value)); - } - - public Where lt(String... values) { - return new Where(Operator.LESS_THAN, left, new $TextArray(values)); - } - - public Where lt(Boolean value) { - return new Where(Operator.LESS_THAN, left, new $Boolean(value)); - } - - public Where lt(Boolean... values) { - return new Where(Operator.LESS_THAN, left, new $BooleanArray(values)); - } - - public Where lt(Integer value) { - return new Where(Operator.LESS_THAN, left, new $Integer(value)); - } - - public Where lt(Integer... values) { - return new Where(Operator.LESS_THAN, left, new $IntegerArray(values)); - } - - public Where lt(Number value) { - return new Where(Operator.LESS_THAN, left, new $Number(value.doubleValue())); - } - - public Where lt(Number... values) { - return new Where(Operator.LESS_THAN, left, new $NumberArray(values)); - } - - public Where lt(Date value) { - return new Where(Operator.LESS_THAN, left, new $Date(value)); - } - - public Where lt(Date... values) { - return new Where(Operator.LESS_THAN, left, new $DateArray(values)); - } - - // LessThanEqual - // ------------------------------------------ - public Where lte(String value) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $Text(value)); - } - - public Where lte(String... values) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $TextArray(values)); - } - - public Where lte(Boolean value) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $Boolean(value)); - } - - public Where lte(Boolean... values) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $BooleanArray(values)); - } - - public Where lte(Integer value) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $Integer(value)); - } - - public Where lte(Integer... values) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $IntegerArray(values)); - } - - public Where lte(Number value) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $Number(value.doubleValue())); - } - - public Where lte(Number... values) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $NumberArray(values)); - } - - public Where lte(Date value) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $Date(value)); - } - - public Where lte(Date... values) { - return new Where(Operator.LESS_THAN_EQUAL, left, new $DateArray(values)); - } - - // GreaterThan - // ------------------------------------------ - public Where gt(String value) { - return new Where(Operator.GREATER_THAN, left, new $Text(value)); - } - - public Where gt(String... values) { - return new Where(Operator.GREATER_THAN, left, new $TextArray(values)); - } - - public Where gt(Boolean value) { - return new Where(Operator.GREATER_THAN, left, new $Boolean(value)); - } - - public Where gt(Boolean... values) { - return new Where(Operator.GREATER_THAN, left, new $BooleanArray(values)); - } - - public Where gt(Integer value) { - return new Where(Operator.GREATER_THAN, left, new $Integer(value)); - } - - public Where gt(Integer... values) { - return new Where(Operator.GREATER_THAN, left, new $IntegerArray(values)); - } - - public Where gt(Number value) { - return new Where(Operator.GREATER_THAN, left, new $Number(value.doubleValue())); - } - - public Where gt(Number... values) { - return new Where(Operator.GREATER_THAN, left, new $NumberArray(values)); - } - - public Where gt(Date value) { - return new Where(Operator.GREATER_THAN, left, new $Date(value)); - } - - public Where gt(Date... values) { - return new Where(Operator.GREATER_THAN, left, new $DateArray(values)); - } - - // GreaterThanEqual - // ------------------------------------------ - public Where gte(String value) { - return new Where(Operator.GREATER_THAN_EQUAL, left, new $Text(value)); - } - - public Where gte(String... values) { - return new Where(Operator.GREATER_THAN, left, new $TextArray(values)); - } - - public Where gte(Boolean value) { - return new Where(Operator.GREATER_THAN, left, new $Boolean(value)); - } - - public Where gte(Boolean... values) { - return new Where(Operator.GREATER_THAN, left, new $BooleanArray(values)); - } - - public Where gte(Integer value) { - return new Where(Operator.GREATER_THAN, left, new $Integer(value)); - } - - public Where gte(Integer... values) { - return new Where(Operator.GREATER_THAN, left, new $IntegerArray(values)); - } - - public Where gte(Number value) { - return new Where(Operator.GREATER_THAN, left, new $Number(value.doubleValue())); - } - - public Where gte(Number... values) { - return new Where(Operator.GREATER_THAN, left, new $NumberArray(values)); - } - - public Where gte(Date value) { - return new Where(Operator.GREATER_THAN, left, new $Date(value)); - } - - public Where gte(Date... values) { - return new Where(Operator.GREATER_THAN, left, new $DateArray(values)); - } - - // Like - // ------------------------------------------ - public Where like(String value) { - return new Where(Operator.LIKE, left, new $Text(value)); - } - - public Where like(String... values) { - return new Where(Operator.LIKE, left, new $TextArray(values)); - } - - public Where like(Boolean value) { - return new Where(Operator.LIKE, left, new $Boolean(value)); - } - - public Where like(Boolean... values) { - return new Where(Operator.LIKE, left, new $BooleanArray(values)); - } - - public Where like(Integer value) { - return new Where(Operator.LIKE, left, new $Integer(value)); - } - - public Where like(Integer... values) { - return new Where(Operator.LIKE, left, new $IntegerArray(values)); - } - - public Where like(Number value) { - return new Where(Operator.LIKE, left, new $Number(value.doubleValue())); - } - - public Where like(Number... values) { - return new Where(Operator.LIKE, left, new $NumberArray(values)); - } - - public Where like(Date value) { - return new Where(Operator.LIKE, left, new $Date(value)); - } - - public Where like(Date... values) { - return new Where(Operator.LIKE, left, new $DateArray(values)); - } - - // ContainsAny - // ------------------------------------------ - public Where containsAny(String value) { - return new Where(Operator.CONTAINS_ANY, left, new $Text(value)); - } - - public Where containsAny(String... values) { - return new Where(Operator.CONTAINS_ANY, left, new $TextArray(values)); - } - - public Where containsAny(Boolean... values) { - return new Where(Operator.CONTAINS_ANY, left, new $BooleanArray(values)); - } - - public Where containsAny(Integer... values) { - return new Where(Operator.CONTAINS_ANY, left, new $IntegerArray(values)); - } - - public Where containsAny(Number... values) { - return new Where(Operator.CONTAINS_ANY, left, new $NumberArray(values)); - } - - public Where containsAny(Date... values) { - return new Where(Operator.CONTAINS_ANY, left, new $DateArray(values)); - } - - // ContainsAll - // ------------------------------------------ - public Where containsAll(String value) { - return new Where(Operator.CONTAINS_ALL, left, new $Text(value)); - } - - public Where containsAll(String... values) { - return new Where(Operator.CONTAINS_ALL, left, new $TextArray(values)); - } - - public Where containsAll(Boolean... values) { - return new Where(Operator.CONTAINS_ALL, left, new $BooleanArray(values)); - } - - public Where containsAll(Integer... values) { - return new Where(Operator.CONTAINS_ALL, left, new $IntegerArray(values)); - } - - public Where containsAll(Number... values) { - return new Where(Operator.CONTAINS_ALL, left, new $NumberArray(values)); - } - - public Where containsAll(Date... values) { - return new Where(Operator.CONTAINS_ALL, left, new $DateArray(values)); - } - - // WithinGeoRange - // ------------------------------------------ - public Where withinGeoRange(float lat, float lon, float maxDistance) { - return new Where(Operator.WITHIN_GEO_RANGE, left, new $GeoRange(lat, lon, maxDistance)); - } - - } - - @Override - public void append(Filters.Builder where) { - switch (operands.size()) { - case 0: - return; - case 1: // no need for operator - operands.get(0).append(where); - return; - default: - if (operator.equals(Operator.AND) || operator.equals(Operator.OR)) { - operands.forEach(op -> { - Filters.Builder nested = Filters.newBuilder(); - op.append(nested); - where.addFilters(nested); - }); - } else { - // Comparison operators: eq, gt, lt, like, etc. - operands.forEach(op -> op.append(where)); - } - } - operator.append(where); - } - - private static class Path implements Operand { - List path = new ArrayList<>(); - - @SafeVarargs - private Path(String... property) { - this.path = Arrays.asList(property); - } - - @Override - public void append(Filters.Builder where) { - // Deprecated, but the current proto doesn't have 'path'. - if (!path.isEmpty()) { - where.addOn(path.get(0)); - } - // FIXME: no way to reference objects rn? - } - } - - @RequiredArgsConstructor - private static class $Text implements Operand { - private final String value; - - @Override - public void append(Filters.Builder where) { - where.setValueText(value); - } - } - - @RequiredArgsConstructor - private static class $TextArray implements Operand { - private final List value; - - @SafeVarargs - private $TextArray(String... values) { - this.value = Arrays.asList(values); - } - - @Override - public void append(Filters.Builder where) { - where.setValueTextArray(WeaviateProtoBase.TextArray.newBuilder().addAllValues(value)); - } - } - - @RequiredArgsConstructor - private static class $Boolean implements Operand { - private final Boolean value; - - @Override - public void append(Filters.Builder where) { - where.setValueBoolean(value); - } - } - - @RequiredArgsConstructor - private static class $BooleanArray implements Operand { - private final List value; - - @SafeVarargs - private $BooleanArray(Boolean... values) { - this.value = Arrays.asList(values); - ; - } - - @Override - public void append(Filters.Builder where) { - where.setValueBooleanArray(WeaviateProtoBase.BooleanArray.newBuilder().addAllValues(value)); - } - } - - @RequiredArgsConstructor - private static class $Integer implements Operand { - private final Integer value; - - @Override - public void append(Filters.Builder where) { - where.setValueInt(value); - } - } - - @RequiredArgsConstructor - private static class $IntegerArray implements Operand { - private final List value; - - @SafeVarargs - private $IntegerArray(Integer... values) { - this.value = Arrays.asList(values); - ; - } - - private List toLongs() { - return value.stream().map(Integer::longValue).collect(Collectors.toList()); - } - - @Override - public void append(Filters.Builder where) { - where.setValueIntArray(WeaviateProtoBase.IntArray.newBuilder().addAllValues(toLongs())); - } - } - - @RequiredArgsConstructor - private static class $Number implements Operand { - private final Number value; - - @Override - public void append(Filters.Builder where) { - where.setValueNumber(value.doubleValue()); - } - } - - @RequiredArgsConstructor - private static class $NumberArray implements Operand { - private final List value; - - @SafeVarargs - private $NumberArray(Number... values) { - this.value = Arrays.asList(values); - } - - private List toDoubles() { - return value.stream().map(Number::doubleValue).collect(Collectors.toList()); - } - - @Override - public void append(Filters.Builder where) { - where.setValueNumberArray(WeaviateProtoBase.NumberArray.newBuilder().addAllValues(toDoubles())); - } - } - - @RequiredArgsConstructor - private static class $Date implements Operand { - private final Date value; - - private static String format(Date date) { - return DateFormatUtils.format(date, "yyyy-MM-dd'T'HH:mm:ssZZZZZ"); - } - - @Override - public void append(Filters.Builder where) { - where.setValueText(format(value)); - } - } - - @RequiredArgsConstructor - private static class $DateArray implements Operand { - private final List value; - - @SafeVarargs - private $DateArray(Date... values) { - this.value = Arrays.asList(values); - ; - } - - private List formatted() { - return value.stream().map(date -> $Date.format(date)).collect(Collectors.toList()); - - } - - @Override - public void append(Filters.Builder where) { - where.setValueTextArray(WeaviateProtoBase.TextArray.newBuilder().addAllValues(formatted())); - } - } - - @RequiredArgsConstructor - private static class $GeoRange implements Operand { - private final Float lat; - private final Float lon; - private final Float distance; - - @Override - public void append(Filters.Builder where) { - where.setValueGeo(WeaviateProtoBase.GeoCoordinatesFilter.newBuilder() - .setLatitude(lat).setLongitude(lon).setDistance(distance)); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/filters/Operator.java b/src/main/java/io/weaviate/client/v1/filters/Operator.java deleted file mode 100644 index faee230f6..000000000 --- a/src/main/java/io/weaviate/client/v1/filters/Operator.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.filters; - -public interface Operator { - - String And = "And"; - String Like = "Like"; - String Or = "Or"; - String Equal = "Equal"; - String Not = "Not"; - String NotEqual = "NotEqual"; - String GreaterThan = "GreaterThan"; - String GreaterThanEqual = "GreaterThanEqual"; - String LessThan = "LessThan"; - String LessThanEqual = "LessThanEqual"; - String WithinGeoRange = "WithinGeoRange"; - String ContainsAny = "ContainsAny"; - String ContainsAll = "ContainsAll"; - String ContainsNone = "ContainsNone"; -} diff --git a/src/main/java/io/weaviate/client/v1/filters/WhereFilter.java b/src/main/java/io/weaviate/client/v1/filters/WhereFilter.java deleted file mode 100644 index b73e57438..000000000 --- a/src/main/java/io/weaviate/client/v1/filters/WhereFilter.java +++ /dev/null @@ -1,176 +0,0 @@ -package io.weaviate.client.v1.filters; - -import java.util.Date; -import java.util.function.Consumer; - -import org.apache.commons.lang3.ArrayUtils; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@FieldDefaults(level = AccessLevel.PRIVATE) -@EqualsAndHashCode -public class WhereFilter { - - WhereFilter[] operands; - String operator; - - String[] path; - Boolean valueBoolean; - Boolean[] valueBooleanArray; - Date valueDate; - Date[] valueDateArray; - GeoRange valueGeoRange; - Integer valueInt; - Integer[] valueIntArray; - Double valueNumber; - Double[] valueNumberArray; - /** - * As of Weaviate v1.19 'valueString' is deprecated and replaced by - * 'valueText'.
- * See data - * types - */ - @Deprecated - String valueString; - @Deprecated - String[] valueStringArray; - String valueText; - String[] valueTextArray; - - public static WhereFilterBuilder builder() { - return new WhereFilterBuilder(); - } - - public static class WhereFilterBuilder { - private WhereFilter[] operands; - private String operator; - private String[] path; - - private Boolean[] valueBooleanArray; - private Date[] valueDateArray; - private Integer[] valueIntArray; - private Double[] valueNumberArray; - private String[] valueStringArray; - private String[] valueTextArray; - private GeoRange valueGeoRange; - - public WhereFilterBuilder operands(WhereFilter... operands) { - this.operands = operands; - return this; - } - - public WhereFilterBuilder operator(String operator) { - this.operator = operator; - return this; - } - - public WhereFilterBuilder path(String... path) { - this.path = path; - return this; - } - - public WhereFilterBuilder valueBoolean(Boolean... valueBoolean) { - valueBooleanArray = valueBoolean; - return this; - } - - public WhereFilterBuilder valueDate(Date... valueDate) { - valueDateArray = valueDate; - return this; - } - - public WhereFilterBuilder valueInt(Integer... valueInt) { - valueIntArray = valueInt; - return this; - } - - public WhereFilterBuilder valueNumber(Double... valueNumber) { - valueNumberArray = valueNumber; - return this; - } - - /** Deprecated: use {@link valueText} instead. */ - @Deprecated - public WhereFilterBuilder valueString(String... valueString) { - valueStringArray = valueString; - return this; - } - - public WhereFilterBuilder valueText(String... valueText) { - valueTextArray = valueText; - return this; - } - - public WhereFilterBuilder valueGeoRange(GeoRange valueGeoRange) { - this.valueGeoRange = valueGeoRange; - return this; - } - - public WhereFilter build() { - WhereFilter f = new WhereFilter(); - f.operands = operands; - f.operator = operator; - f.path = path; - f.valueGeoRange = valueGeoRange; - assignSingleOrArray(valueBooleanArray, s -> f.valueBoolean = s, a -> f.valueBooleanArray = a); - assignSingleOrArray(valueDateArray, s -> f.valueDate = s, a -> f.valueDateArray = a); - assignSingleOrArray(valueIntArray, s -> f.valueInt = s, a -> f.valueIntArray = a); - assignSingleOrArray(valueNumberArray, s -> f.valueNumber = s, a -> f.valueNumberArray = a); - assignSingleOrArray(valueStringArray, s -> f.valueString = s, a -> f.valueStringArray = a); - assignSingleOrArray(valueTextArray, s -> f.valueText = s, a -> f.valueTextArray = a); - - return f; - } - - private void assignSingleOrArray(T[] values, Consumer single, Consumer array) { - if (ArrayUtils.isNotEmpty(values)) { - if (values.length > 1 || Operator.ContainsAny.equals(operator) || Operator.ContainsAll.equals(operator) - || Operator.ContainsNone.equals(operator)) { - array.accept(values); - } else { - single.accept(values[0]); - } - } - } - } - - @Getter - @Builder - @ToString - @FieldDefaults(level = AccessLevel.PRIVATE) - @EqualsAndHashCode - public static class GeoRange { - - GeoDistance distance; - GeoCoordinates geoCoordinates; - } - - @Getter - @Builder - @ToString - @FieldDefaults(level = AccessLevel.PRIVATE) - @EqualsAndHashCode - public static class GeoDistance { - - Float max; - } - - @Getter - @Builder - @ToString - @FieldDefaults(level = AccessLevel.PRIVATE) - @EqualsAndHashCode - public static class GeoCoordinates { - - Float latitude; - Float longitude; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/GraphQL.java b/src/main/java/io/weaviate/client/v1/graphql/GraphQL.java deleted file mode 100644 index 7ff814a97..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/GraphQL.java +++ /dev/null @@ -1,120 +0,0 @@ -package io.weaviate.client.v1.graphql; - -import io.weaviate.client.v1.graphql.query.Aggregate; -import io.weaviate.client.v1.graphql.query.Explore; -import io.weaviate.client.v1.graphql.query.Get; -import io.weaviate.client.v1.graphql.query.Raw; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; - -public class GraphQL { - private Config config; - private HttpClient httpClient; - - public static class Arguments { - public NearTextArgument.NearTextArgumentBuilder nearTextArgBuilder() { - return NearTextArgument.builder(); - } - - public Bm25Argument.Bm25ArgumentBuilder bm25ArgBuilder() { - return Bm25Argument.builder(); - } - - public HybridArgument.HybridArgumentBuilder hybridArgBuilder() { - return HybridArgument.builder(); - } - - public AskArgument.AskArgumentBuilder askArgBuilder() { - return AskArgument.builder(); - } - - public NearTextMoveParameters.NearTextMoveParametersBuilder nearTextMoveParameterBuilder() { - return NearTextMoveParameters.builder(); - } - - public NearObjectArgument.NearObjectArgumentBuilder nearObjectArgBuilder() { - return NearObjectArgument.builder(); - } - - public NearVectorArgument.NearVectorArgumentBuilder nearVectorArgBuilder() { - return NearVectorArgument.builder(); - } - - public NearImageArgument.NearImageArgumentBuilder nearImageArgBuilder() { - return NearImageArgument.builder(); - } - - public NearAudioArgument.NearAudioArgumentBuilder nearAudioArgBuilder() { - return NearAudioArgument.builder(); - } - - public NearVideoArgument.NearVideoArgumentBuilder nearVideoArgBuilder() { - return NearVideoArgument.builder(); - } - - public NearDepthArgument.NearDepthArgumentBuilder nearDepthArgBuilder() { - return NearDepthArgument.builder(); - } - - public NearThermalArgument.NearThermalArgumentBuilder nearThermalArgBuilder() { - return NearThermalArgument.builder(); - } - - public NearImuArgument.NearImuArgumentBuilder nearImuArgBuilder() { - return NearImuArgument.builder(); - } - - public GroupArgument.GroupArgumentBuilder groupArgBuilder() { - return GroupArgument.builder(); - } - - public SortArgument.SortArgumentBuilder sortArgBuilder() { - return SortArgument.builder(); - } - - public GroupByArgument.GroupByArgumentBuilder groupByArgBuilder() { - return GroupByArgument.builder(); - } - } - - public GraphQL(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public Get get() { - return new Get(httpClient, config); - } - - public Raw raw() { - return new Raw(httpClient, config); - } - - public Explore explore() { - return new Explore(httpClient, config); - } - - public Aggregate aggregate() { - return new Aggregate(httpClient, config); - } - - public GraphQL.Arguments arguments() { - return new GraphQL.Arguments(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/ExploreFields.java b/src/main/java/io/weaviate/client/v1/graphql/model/ExploreFields.java deleted file mode 100644 index ed58ef7a0..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/ExploreFields.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -public enum ExploreFields { - CERTAINTY("certainty"), - DISTANCE("distance"), - BEACON("beacon"), - CLASS_NAME("className"); - - private final String field; - - ExploreFields(String field) { - this.field = field; - } - - @Override - public String toString() { - return field; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLError.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLError.java deleted file mode 100644 index 47ca2be0d..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLError.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class GraphQLError { - String message; - String[] path; - GraphQLErrorLocationsItems[] locations; -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLErrorLocationsItems.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLErrorLocationsItems.java deleted file mode 100644 index cbf99220a..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLErrorLocationsItems.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class GraphQLErrorLocationsItems { - Long column; - Long line; -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLGetBaseObject.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLGetBaseObject.java deleted file mode 100644 index 8016050d4..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLGetBaseObject.java +++ /dev/null @@ -1,72 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import com.google.gson.annotations.SerializedName; -import java.util.List; -import java.util.Map; -import lombok.AllArgsConstructor; -import lombok.Getter; - -@Getter -public class GraphQLGetBaseObject { - @SerializedName(value = "_additional") - Additional additional; - - @Getter - public static class Additional { - String id; - Float certainty; - Float distance; - String creationTimeUnix; - String lastUpdateTimeUnix; - String explainScore; - String score; - Float[] vector; - Map vectors; - Generate generate; - Group group; - - @Getter - public static class Generate { - String singleResult; - String groupedResult; - String error; - Debug debug; - - @Getter - public static class Debug { - String prompt; - } - } - - @Getter - public static class Group { - public String id; - public GroupedBy groupedBy; - public Integer count; - public Float maxDistance; - public Float minDistance; - public List hits; - - @Getter - public static class GroupedBy { - public String value; - public String[] path; - } - - @Getter - @AllArgsConstructor - public static class GroupHit { - @SerializedName("properties") - Map properties; - @SerializedName(value = "_additional") - AdditionalGroupHit additional; - - @Getter - public static class AdditionalGroupHit { - String id; - Float distance; - } - } - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLQuery.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLQuery.java deleted file mode 100644 index 0c15c8e6d..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLQuery.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class GraphQLQuery { - String operationName; - String query; - Object variables; -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLResponse.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLResponse.java deleted file mode 100644 index 5c8feab0e..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLResponse.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import io.weaviate.client.base.WeaviateErrorMessage; -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class GraphQLResponse { - T data; - GraphQLError[] errors; - - - /** - * Extract the 'message' portion of every error in the response, omitting 'path' and 'location'. - * - * @return Non-throwable WeaviateErrorMessages - */ - public List errorMessages() { - if (errors == null || errors.length == 0) { - return null; - } - return Arrays.stream(errors) - .map(err -> new WeaviateErrorMessage(err.getMessage(), null)) - .collect(Collectors.toList()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponse.java b/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponse.java deleted file mode 100644 index 9af183107..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponse.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor -@FieldDefaults(level = AccessLevel.PRIVATE) -public class GraphQLTypedResponse { - Operation data; - GraphQLError[] errors; - - @Getter - @ToString - @EqualsAndHashCode - @AllArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class Operation { - @SerializedName(value = "Get", alternate = {"Aggregate", "Explore"}) - private T objects; - } -} - - diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/Aggregate.java b/src/main/java/io/weaviate/client/v1/graphql/query/Aggregate.java deleted file mode 100644 index 3d846b940..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/Aggregate.java +++ /dev/null @@ -1,127 +0,0 @@ -package io.weaviate.client.v1.graphql.query; - -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.builder.AggregateBuilder; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; - -public class Aggregate extends BaseClient implements ClientResult { - private final AggregateBuilder.AggregateBuilderBuilder aggregateBuilder; - - public Aggregate(HttpClient httpClient, Config config) { - super(httpClient, config); - aggregateBuilder = AggregateBuilder.builder(); - } - - public Aggregate withClassName(String className) { - aggregateBuilder.className(className); - return this; - } - - public Aggregate withFields(Field... fields) { - aggregateBuilder.fields(Fields.builder().fields(fields).build()); - return this; - } - - @Deprecated - public Aggregate withWhere(WhereFilter where) { - return withWhere(WhereArgument.builder().filter(where).build()); - } - - public Aggregate withWhere(WhereArgument where) { - aggregateBuilder.withWhereFilter(where); - return this; - } - - public Aggregate withGroupBy(String propertyName) { - aggregateBuilder.groupByClausePropertyName(propertyName); - return this; - } - - public Aggregate withAsk(AskArgument ask) { - aggregateBuilder.withAskArgument(ask); - return this; - } - - public Aggregate withNearText(NearTextArgument withNearTextFilter) { - aggregateBuilder.withNearTextFilter(withNearTextFilter); - return this; - } - - public Aggregate withNearObject(NearObjectArgument withNearObjectFilter) { - aggregateBuilder.withNearObjectFilter(withNearObjectFilter); - return this; - } - - public Aggregate withNearVector(NearVectorArgument withNearVectorFilter) { - aggregateBuilder.withNearVectorFilter(withNearVectorFilter); - return this; - } - - public Aggregate withNearImage(NearImageArgument nearImage) { - aggregateBuilder.withNearImageFilter(nearImage); - return this; - } - - public Aggregate withNearAudio(NearAudioArgument nearAudio) { - aggregateBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Aggregate withNearVideo(NearVideoArgument nearVideo) { - aggregateBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Aggregate withNearDepth(NearDepthArgument nearDepth) { - aggregateBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Aggregate withNearThermal(NearThermalArgument nearThermal) { - aggregateBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Aggregate withNearImu(NearImuArgument nearImu) { - aggregateBuilder.withNearImuFilter(nearImu); - return this; - } - - public Aggregate withObjectLimit(Integer objectLimit) { - aggregateBuilder.objectLimit(objectLimit); - return this; - } - - public Aggregate withTenant(String tenant) { - aggregateBuilder.tenant(tenant); - return this; - } - - @Override - public Result run() { - String aggregateQuery = aggregateBuilder.build().buildQuery(); - GraphQLQuery query = GraphQLQuery.builder().query(aggregateQuery).build(); - Response resp = sendPostRequest("/graphql", query, GraphQLResponse.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/Explore.java b/src/main/java/io/weaviate/client/v1/graphql/query/Explore.java deleted file mode 100644 index 603b6ac41..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/Explore.java +++ /dev/null @@ -1,104 +0,0 @@ -package io.weaviate.client.v1.graphql.query; - -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.builder.ExploreBuilder; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.graphql.model.ExploreFields; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; - -public class Explore extends BaseClient implements ClientResult { - private final ExploreBuilder.ExploreBuilderBuilder exploreBuilder; - - public Explore(HttpClient httpClient, Config config) { - super(httpClient, config); - exploreBuilder = ExploreBuilder.builder(); - } - - public Explore withFields(ExploreFields... fields) { - exploreBuilder.fields(fields); - return this; - } - - public Explore withLimit(Integer limit) { - exploreBuilder.limit(limit); - return this; - } - - public Explore withOffset(Integer offset) { - exploreBuilder.offset(offset); - return this; - } - - public Explore withAsk(AskArgument ask) { - exploreBuilder.withAskArgument(ask); - return this; - } - - public Explore withNearText(NearTextArgument nearText) { - exploreBuilder.withNearText(nearText); - return this; - } - - public Explore withNearObject(NearObjectArgument nearObject) { - exploreBuilder.withNearObjectFilter(nearObject); - return this; - } - - public Explore withNearVector(NearVectorArgument nearVector) { - exploreBuilder.withNearVectorFilter(nearVector); - return this; - } - - public Explore withNearImage(NearImageArgument nearImage) { - exploreBuilder.withNearImageFilter(nearImage); - return this; - } - - public Explore withNearAudio(NearAudioArgument nearAudio) { - exploreBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Explore withNearVideo(NearVideoArgument nearVideo) { - exploreBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Explore withNearDepth(NearDepthArgument nearDepth) { - exploreBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Explore withNearThermal(NearThermalArgument nearThermal) { - exploreBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Explore withNearImu(NearImuArgument nearImu) { - exploreBuilder.withNearImuFilter(nearImu); - return this; - } - - @Override - public Result run() { - String exploreQuery = exploreBuilder.build().buildQuery(); - GraphQLQuery query = GraphQLQuery.builder().query(exploreQuery).build(); - Response resp = sendPostRequest("/graphql", query, GraphQLResponse.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/Get.java b/src/main/java/io/weaviate/client/v1/graphql/query/Get.java deleted file mode 100644 index f181f15d1..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/Get.java +++ /dev/null @@ -1,225 +0,0 @@ -package io.weaviate.client.v1.graphql.query; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseGraphQLClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLGetBaseObject; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArguments; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.builder.GetBuilder; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder; - -public class Get extends BaseGraphQLClient implements ClientResult { - private final GetBuilder.GetBuilderBuilder getBuilder; - - public Get(HttpClient httpClient, Config config) { - super(httpClient, config); - getBuilder = GetBuilder.builder(); - } - - public Get withClassName(String className) { - getBuilder.className(className); - return this; - } - - public Get withFields(Field... fields) { - getBuilder.fields(Fields.builder().fields(fields).build()); - return this; - } - - @Deprecated - public Get withWhere(WhereFilter where) { - return withWhere(WhereArgument.builder().filter(where).build()); - } - - public Get withWhere(WhereArgument where) { - getBuilder.withWhereFilter(where); - return this; - } - - public Get withLimit(Integer limit) { - getBuilder.limit(limit); - return this; - } - - public Get withOffset(Integer offset) { - getBuilder.offset(offset); - return this; - } - - public Get withAfter(String after) { - getBuilder.after(after); - return this; - } - - public Get withBm25(Bm25Argument bm25) { - getBuilder.withBm25Filter(bm25); - return this; - } - - public Get withHybrid(HybridArgument hybrid) { - getBuilder.withHybridFilter(hybrid); - return this; - } - - public Get withAsk(AskArgument ask) { - getBuilder.withAskArgument(ask); - return this; - } - - public Get withNearText(NearTextArgument nearText) { - getBuilder.withNearTextFilter(nearText); - return this; - } - - public Get withNearObject(NearObjectArgument nearObject) { - getBuilder.withNearObjectFilter(nearObject); - return this; - } - - public Get withNearVector(NearVectorArgument nearVector) { - getBuilder.withNearVectorFilter(nearVector); - return this; - } - - public Get withNearImage(NearImageArgument nearImage) { - getBuilder.withNearImageFilter(nearImage); - return this; - } - - public Get withNearAudio(NearAudioArgument nearAudio) { - getBuilder.withNearAudioFilter(nearAudio); - return this; - } - - public Get withNearVideo(NearVideoArgument nearVideo) { - getBuilder.withNearVideoFilter(nearVideo); - return this; - } - - public Get withNearDepth(NearDepthArgument nearDepth) { - getBuilder.withNearDepthFilter(nearDepth); - return this; - } - - public Get withNearThermal(NearThermalArgument nearThermal) { - getBuilder.withNearThermalFilter(nearThermal); - return this; - } - - public Get withNearImu(NearImuArgument nearImu) { - getBuilder.withNearImuFilter(nearImu); - return this; - } - - public Get withGroup(GroupArgument group) { - getBuilder.withGroupArgument(group); - return this; - } - - public Get withSort(SortArgument... sort) { - getBuilder.withSortArguments(SortArguments.builder().sort(sort).build()); - return this; - } - - public Get withGenerativeSearch(GenerativeSearchBuilder generativeSearch) { - getBuilder.withGenerativeSearch(generativeSearch); - return this; - } - - public Get withConsistencyLevel(String level) { - getBuilder.withConsistencyLevel(level); - return this; - } - - public Get withGroupBy(GroupByArgument groupBy) { - getBuilder.withGroupByArgument(groupBy); - return this; - } - - public Get withTenant(String tenant) { - getBuilder.tenant(tenant); - return this; - } - - public Get withAutocut(Integer autocut) { - getBuilder.autocut(autocut); - return this; - } - - @Override - public Result run() { - String getQuery = getBuilder.build().buildQuery(); - GraphQLQuery query = GraphQLQuery.builder().query(getQuery).build(); - Response resp = sendPostRequest("/graphql", query, GraphQLResponse.class); - return new Result<>(resp); - } - - /** - * This method provides a better way of serializing a GraphQL response using one's defined classes. - * Example: - * In Weaviate we have defined collection named Soup with name and price properties. - * For client to be able to properly serialize GraphQL response to an Object with - * convenient methods accessing GraphQL settings one can create a class, example: - *

{@code
-   * import com.google.gson.annotations.SerializedName;
-   *
-   * public class Soups {
-   *   {@literal @}SerializedName(value = "Soup")
-   *   List soups;
-   *
-   *   public List getSoups() {
-   *     return soups;
-   *   }
-   *
-   *   public static class Soup extends GraphQLGetBaseObject {
-   *     String name;
-   *     Float price;
-   *
-   *     public String getName() {
-   *       return name;
-   *     }
-   *
-   *     public Float getPrice() {
-   *       return price;
-   *     }
-   *   }
-   * }
-   * }
- * - * @param classOfC - class describing Weaviate object, example: Soups class - * @param - Class of C - * @return Result of GraphQLTypedResponse of a given class - * @see GraphQLGetBaseObject - */ - public Result> run(Class classOfC) { - String getQuery = getBuilder.build().buildQuery(); - GraphQLQuery query = GraphQLQuery.builder().query(getQuery).build(); - Response> resp = sendGraphQLTypedRequest(query, classOfC); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/Raw.java b/src/main/java/io/weaviate/client/v1/graphql/query/Raw.java deleted file mode 100644 index a8846b09c..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/Raw.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.weaviate.client.v1.graphql.query; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.graphql.model.GraphQLQuery; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; - -public class Raw extends BaseClient implements ClientResult { - private String query; - - public Raw(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Raw withQuery(String query) { - this.query = query; - return this; - } - - @Override - public Result run() { - GraphQLQuery query = GraphQLQuery.builder().query(this.query).build(); - Response resp = sendPostRequest("/graphql", query, GraphQLResponse.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Argument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/Argument.java deleted file mode 100644 index 3889d7236..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Argument.java +++ /dev/null @@ -1,5 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -public interface Argument { - String build(); -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/AskArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/AskArgument.java deleted file mode 100644 index fb91abb87..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/AskArgument.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -import java.util.LinkedHashSet; -import java.util.Set; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class AskArgument implements Argument { - String question; - String[] properties; - Float certainty; - Float distance; - Boolean autocorrect; - Boolean rerank; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(question)) { - arg.add(String.format("question:%s", Serializer.quote(question))); - } - if (ArrayUtils.isNotEmpty(properties)) { - arg.add(String.format("properties:%s", Serializer.arrayWithQuotes(properties))); - } - if (certainty != null) { - arg.add(String.format("certainty:%s", certainty)); - } - if (distance != null) { - arg.add(String.format("distance:%s", distance)); - } - if (autocorrect != null) { - arg.add(String.format("autocorrect:%s", autocorrect)); - } - if (rerank != null) { - arg.add(String.format("rerank:%s", rerank)); - } - - return String.format("ask:{%s}", String.join(" ", arg)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Bm25Argument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/Bm25Argument.java deleted file mode 100644 index 0d17462f8..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Bm25Argument.java +++ /dev/null @@ -1,63 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashSet; -import java.util.Set; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Bm25Argument implements Argument { - String query; - String[] properties; - SearchOperator searchOperator; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - arg.add(String.format("query:%s", Serializer.quote(query))); - if (properties != null) { - arg.add(String.format("properties:%s", Serializer.arrayWithQuotes(properties))); - } - if (searchOperator != null) { - arg.add(String.format("searchOperator:%s", searchOperator.build())); - } - - return String.format("bm25:{%s}", String.join(" ", arg)); - } - - @AllArgsConstructor(access = AccessLevel.PRIVATE) - public static class SearchOperator implements Argument { - private static final String OR = "Or"; - private static final String AND = "And"; - - private String operator; - private int minimumMatch; - - public static SearchOperator and() { - return new SearchOperator(AND, 0); // minimumMatch ignored for And - } - - public static SearchOperator or(int minimumMatch) { - return new SearchOperator(OR, minimumMatch); - } - - @Override - public String build() { - // While minimumOrTokensMatch is ignored, it should nevertheless be included - // in the query, otherwise the server refuses to execute it. - return String.format("{operator:%s minimumOrTokensMatch:%s}", operator, minimumMatch); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/FusionType.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/FusionType.java deleted file mode 100644 index 88812ff96..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/FusionType.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -public interface FusionType { - - String RANKED = "rankedFusion"; - String RELATIVE_SCORE = "relativeScoreFusion"; -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupArgument.java deleted file mode 100644 index 0b6ece77d..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupArgument.java +++ /dev/null @@ -1,35 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.util.LinkedHashSet; -import java.util.Set; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class GroupArgument implements Argument { - GroupType type; - Float force; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (type != null) { - arg.add(String.format("type:%s", type)); - } - if (force != null) { - arg.add(String.format("force:%s", force)); - } - - return String.format("group:{%s}", String.join(" ", arg)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgument.java deleted file mode 100644 index f9fe9204f..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgument.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import java.util.LinkedHashSet; -import java.util.Set; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class GroupByArgument implements Argument { - String[] path; - Integer groups; - Integer objectsPerGroup; - - @Override - public String build() { - Set args = new LinkedHashSet<>(); - - if (ArrayUtils.isNotEmpty(path)) { - args.add(String.format("path:%s", Serializer.arrayWithQuotes(path))); - } - if (groups != null) { - args.add(String.format("groups:%s", groups)); - } - if (objectsPerGroup != null) { - args.add(String.format("objectsPerGroup:%s", objectsPerGroup)); - } - - return String.format("groupBy:{%s}", String.join(" ", args)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupType.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupType.java deleted file mode 100644 index cebce68cf..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/GroupType.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -public enum GroupType { - merge("merge"), - closest("closest"); - - private final String type; - - GroupType(String type) { - this.type = type; - } - - @Override - public String toString() { - return type; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/HybridArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/HybridArgument.java deleted file mode 100644 index 619ee5706..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/HybridArgument.java +++ /dev/null @@ -1,85 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashSet; -import java.util.Set; - -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class HybridArgument implements Argument { - String query; - Float alpha; - Float maxVectorDistance; - Float[] vector; - String fusionType; - String[] properties; - String[] targetVectors; - Searches searches; - Targets targets; - Bm25Argument.SearchOperator bm25SearchOperator; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - arg.add(String.format("query:%s", Serializer.quote(query))); - if (vector != null) { - arg.add(String.format("vector:%s", Serializer.array(vector))); - } - if (alpha != null) { - arg.add(String.format("alpha:%s", alpha)); - } - if (maxVectorDistance != null) { - arg.add(String.format("maxVectorDistance:%s", maxVectorDistance)); - } - if (ArrayUtils.isNotEmpty(properties)) { - arg.add(String.format("properties:%s", Serializer.arrayWithQuotes(properties))); - } - if (StringUtils.isNotBlank(fusionType)) { - arg.add(String.format("fusionType:%s", fusionType)); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - arg.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (searches != null && (searches.nearVector != null || searches.nearText != null)) { - Set searchesArgs = new LinkedHashSet<>(); - if (searches.nearVector != null) { - searchesArgs.add(searches.nearVector.build()); - } - if (searches.nearText != null) { - searchesArgs.add(searches.nearText.build()); - } - arg.add(String.format("searches:{%s}", String.join(" ", searchesArgs))); - } - if (bm25SearchOperator != null) { - arg.add(String.format("bm25SearchOperator:%s", bm25SearchOperator.build())); - } - if (targets != null) { - arg.add(String.format("%s", targets.build())); - } - - return String.format("hybrid:{%s}", String.join(" ", arg)); - } - - @Getter - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Searches { - NearVectorArgument nearVector; - NearTextArgument nearText; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgument.java deleted file mode 100644 index d5607acde..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearAudioArgument implements Argument { - - String audio; - File audioFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(audio) - .dataFile(audioFile) - .targets(targets) - .mediaField("audio") - .mediaName("nearAudio") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgument.java deleted file mode 100644 index b2deb16bf..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearDepthArgument implements Argument { - - String depth; - File depthFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(depth) - .dataFile(depthFile) - .targets(targets) - .mediaField("depth") - .mediaName("nearDepth") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgument.java deleted file mode 100644 index 4ca3b2f77..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearImageArgument implements Argument { - - String image; - File imageFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(image) - .dataFile(imageFile) - .targets(targets) - .mediaField("image") - .mediaName("nearImage") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgument.java deleted file mode 100644 index b84dde5a2..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearImuArgument implements Argument { - - String imu; - File imuFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(imu) - .dataFile(imuFile) - .targets(targets) - .mediaField("imu") - .mediaName("nearIMU") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelper.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelper.java deleted file mode 100644 index 6d7574a7f..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelper.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -import java.io.File; -import java.nio.file.Files; -import java.nio.file.Paths; -import java.util.Base64; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -@Builder -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -class NearMediaArgumentHelper { - - String mediaName; - String mediaField; - String data; - File dataFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - - public String build() { - Set fields = new LinkedHashSet<>(); - - String content = getContent(); - if (StringUtils.isNotBlank(content)) { - fields.add(String.format("%s:%s", mediaField, Serializer.quote(content))); - } - if (certainty != null) { - fields.add(String.format("certainty:%s", certainty)); - } - if (distance != null) { - fields.add(String.format("distance:%s", distance)); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - fields.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (targets != null) { - fields.add(String.format("%s", targets.build())); - } - - return String.format("%s:{%s}", mediaName, String.join(" ", fields)); - } - - private String getContent() { - if (StringUtils.isNotBlank(data)) { - if (data.startsWith("data:")) { - String base64 = ";base64,"; - return data.substring(data.indexOf(base64) + base64.length()); - } - return data; - } - if (dataFile != null) { - return readFile(dataFile); - } - return null; - } - - private String readFile(File file) { - try { - byte[] content = Files.readAllBytes(Paths.get(file.toURI())); - return Base64.getEncoder().encodeToString(content); - } catch (Exception e) { - return null; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgument.java deleted file mode 100644 index 27118d0aa..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgument.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashSet; -import java.util.Set; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearObjectArgument implements Argument { - String id; - String beacon; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(id)) { - arg.add(String.format("id:%s", Serializer.quote(id))); - } - if (StringUtils.isNotBlank(beacon)) { - arg.add(String.format("beacon:%s", Serializer.quote(beacon))); - } - if (certainty != null) { - arg.add(String.format("certainty:%s", certainty)); - } - if (distance != null) { - arg.add(String.format("distance:%s", distance)); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - arg.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (targets != null) { - arg.add(String.format("%s", targets.build())); - } - - return String.format("nearObject:{%s}", String.join(" ", arg)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgument.java deleted file mode 100644 index 8605f639a..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgument.java +++ /dev/null @@ -1,91 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -import java.util.LinkedHashSet; -import java.util.Set; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearTextArgument implements Argument { - String[] concepts; - Float certainty; - Float distance; - NearTextMoveParameters moveTo; - NearTextMoveParameters moveAwayFrom; - Boolean autocorrect; - String[] targetVectors; - Targets targets; - - private String buildMoveParam(String name, NearTextMoveParameters moveParam) { - Set arg = new LinkedHashSet<>(); - - if (ArrayUtils.isNotEmpty(moveParam.getConcepts())) { - arg.add(String.format("concepts:%s", Serializer.arrayWithQuotes(moveParam.getConcepts()))); - } - if (moveParam.getForce() != null) { - arg.add(String.format("force:%s", moveParam.getForce())); - } - if (ArrayUtils.isNotEmpty(moveParam.getObjects())) { - arg.add(String.format("objects:%s", Serializer.array(moveParam.getObjects(), this::mapObjectMoveToStringClause))); - } - - return String.format("%s:{%s}", name, String.join(" ", arg)); - } - - private String mapObjectMoveToStringClause(NearTextMoveParameters.ObjectMove obj) { - Set objectsArg = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(obj.getId())) { - objectsArg.add(String.format("id:%s", Serializer.quote(obj.getId()))); - } - if (StringUtils.isNotBlank(obj.getBeacon())) { - objectsArg.add(String.format("beacon:%s", Serializer.quote(obj.getBeacon()))); - } - - return String.format("{%s}", String.join(" ", objectsArg)); - } - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (ArrayUtils.isNotEmpty(concepts)) { - arg.add(String.format("concepts:%s", Serializer.arrayWithQuotes(concepts))); - } - if (certainty != null) { - arg.add(String.format("certainty:%s", certainty)); - } - if (distance != null) { - arg.add(String.format("distance:%s", distance)); - } - if (moveTo != null) { - arg.add(buildMoveParam("moveTo", moveTo)); - } - if (moveAwayFrom != null) { - arg.add(buildMoveParam("moveAwayFrom", moveAwayFrom)); - } - if (autocorrect != null) { - arg.add(String.format("autocorrect:%s", autocorrect)); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - arg.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (targets != null) { - arg.add(String.format("%s", targets.build())); - } - - return String.format("nearText:{%s}", String.join(" ", arg)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextMoveParameters.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextMoveParameters.java deleted file mode 100644 index 9544f44fc..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearTextMoveParameters.java +++ /dev/null @@ -1,29 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearTextMoveParameters { - String[] concepts; - Float force; - ObjectMove[] objects; - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(level = AccessLevel.PRIVATE) - public static class ObjectMove { - String id; - String beacon; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgument.java deleted file mode 100644 index 63f2466af..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearThermalArgument implements Argument { - - String thermal; - File thermalFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(thermal) - .dataFile(thermalFile) - .targets(targets) - .mediaField("thermal") - .mediaName("nearThermal") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgument.java deleted file mode 100644 index 2ec307797..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgument.java +++ /dev/null @@ -1,137 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.apache.commons.lang3.ArrayUtils; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearVectorArgument implements Argument { - /** One-dimensional search vector. */ - Float[] vector; - /** Multi-dimensional search vector. */ - Float[][] multiVector; - Float certainty; - Float distance; - String[] targetVectors; - Map vectorsPerTarget; - Targets targets; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (vector != null) { - arg.add(String.format("vector:%s", Serializer.array(vector))); - } else if (multiVector != null) { - arg.add(String.format("vector:%s", Serializer.array(multiVector))); - } - if (certainty != null) { - arg.add(String.format("certainty:%s", certainty)); - } - if (distance != null) { - arg.add(String.format("distance:%s", distance)); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - arg.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (vectorsPerTarget != null && !vectorsPerTarget.isEmpty()) { - Set vectorPerTargetArg = new LinkedHashSet<>(); - for (Map.Entry e : vectorsPerTarget.entrySet()) { - Float[][] vectors = e.getValue(); - vectorPerTargetArg.add(String.format("%s:%s", e.getKey(), - vectors.length == 1 ? Serializer.array(vectors[0]) : Serializer.array(vectors))); - } - arg.add(String.format("vectorPerTarget:{%s}", String.join(" ", vectorPerTargetArg))); - } - if (targets != null) { - arg.add(String.format("%s", withValidTargetVectors(this.targets).build())); - } - - return String.format("nearVector:{%s}", String.join(" ", arg)); - } - - /** - * withValidTargetVectors makes sure the target names are repeated for each - * target vector, - * which is required by server, but may be easily overlooked by the user. - * - *

- * Note, too, that in case the user fails to pass a value in targetVectors - * altogether, it will not be added to the query. - * - * @return A copy of the Targets with validated target vectors. - */ - private Targets withValidTargetVectors(Targets targets) { - return Targets.builder().combinationMethod(targets.getCombinationMethod()).weightsMulti(targets.getWeights()) - .targetVectors(prepareTargetVectors(targets.getTargetVectors())).build(); - } - - /** - * prepareTargetVectors adds appends the target name for each target vector - * associated with it. - */ - private String[] prepareTargetVectors(String[] targets) { - List out = new ArrayList<>(); - for (String target : targets) { - if (this.vectorsPerTarget.containsKey(target)) { - int l = this.vectorsPerTarget.get(target).length; - for (int i = 0; i < l; i++) { - out.add(target); - } - } else { - out.add(target); - } - } - return out.toArray(new String[0]); - } - - // Extend Lombok's builder to overload some methods. - public static class NearVectorArgumentBuilder { - Map vectorsPerTarget = new LinkedHashMap<>(); - - public NearVectorArgumentBuilder vectorPerTarget(Map vectors) { - this.vectorsPerTarget.clear(); // Overwrite the existing entries each time this is called. - for (Map.Entry e : vectors.entrySet()) { - this.vectorsPerTarget.put(e.getKey(), new Float[][] { e.getValue() }); - } - return this; - } - - public NearVectorArgumentBuilder vectorsPerTarget(Map vectors) { - this.vectorsPerTarget = vectors; - return this; - } - - public NearVectorArgumentBuilder vector(Float[] vector) { - this.vector = vector; - return this; - } - - public NearVectorArgumentBuilder vector(Float[][] multiVector) { - this.multiVector = multiVector; - return this; - } - - /** Hide this method to promote the overloaded {@link #vector(Float[][])}. */ - private NearVectorArgumentBuilder multiVector(Float[][] _vectors) { - return this; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgument.java deleted file mode 100644 index 2ced71888..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgument.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.io.File; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class NearVideoArgument implements Argument { - - String video; - File videoFile; - Float certainty; - Float distance; - String[] targetVectors; - Targets targets; - - @Override - public String build() { - return NearMediaArgumentHelper.builder() - .certainty(certainty) - .distance(distance) - .targetVectors(targetVectors) - .data(video) - .dataFile(videoFile) - .targets(targets) - .mediaField("video") - .mediaName("nearVideo") - .build().build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArgument.java deleted file mode 100644 index 0e5e2b90d..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArgument.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; - -import java.util.LinkedHashSet; -import java.util.Set; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class SortArgument implements Argument { - String[] path; - SortOrder order; - - @Override - public String build() { - Set arg = new LinkedHashSet<>(); - - if (ArrayUtils.isNotEmpty(path)) { - arg.add(String.format("path:%s", Serializer.arrayWithQuotes(path))); - } - if (order != null) { - arg.add(String.format("order:%s", order)); - } - - return String.format("{%s}", String.join(" ", arg)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArguments.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArguments.java deleted file mode 100644 index da45a8da7..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortArguments.java +++ /dev/null @@ -1,27 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class SortArguments implements Argument { - SortArgument[] sort; - - @Override - public String build() { - if (ArrayUtils.isNotEmpty(sort)) { - return String.format("sort:%s", Serializer.array(sort, SortArgument::build)); - } - return "sort:[]"; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortOrder.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortOrder.java deleted file mode 100644 index 35836d67f..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/SortOrder.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -public enum SortOrder { - asc("asc"), - desc("desc"); - - private final String order; - - SortOrder(String order) { - this.order = order; - } - - @Override - public String toString() { - return order; - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Targets.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/Targets.java deleted file mode 100644 index ffce7b589..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/Targets.java +++ /dev/null @@ -1,90 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.Map; -import java.util.Set; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Targets { - CombinationMethod combinationMethod; - String[] targetVectors; - Map weights; - - public enum CombinationMethod { - minimum("minimum"), - average("average"), - sum("sum"), - manualWeights("manualWeights"), - relativeScore("relativeScore"); - - private final String type; - - CombinationMethod(String type) { - this.type = type; - } - - @Override - public String toString() { - return type; - } - } - - String build() { - Set arg = new LinkedHashSet<>(); - - if (combinationMethod != null) { - arg.add(String.format("combinationMethod:%s", combinationMethod.name())); - } - if (ArrayUtils.isNotEmpty(targetVectors)) { - arg.add(String.format("targetVectors:%s", Serializer.arrayWithQuotes(targetVectors))); - } - if (weights != null && !weights.isEmpty()) { - Set weightsArg = new LinkedHashSet<>(); - for (Map.Entry e : weights.entrySet()) { - Float[] weightsPerTarget = e.getValue(); - String target = e.getKey(); - - String weight = Serializer.array(weightsPerTarget); - if (weightsPerTarget.length == 1) { - weight = weightsPerTarget[0].toString(); - } - weightsArg.add(String.format("%s:%s", target, weight)); - } - arg.add(String.format("weights:{%s}", String.join(" ", weightsArg))); - } - - return String.format("targets:{%s}", String.join(" ", arg)); - } - - // Extend lombok's builder to overload some methods. - public static class TargetsBuilder { - Map weights = new LinkedHashMap<>(); - - public TargetsBuilder weights(Map weights) { - this.weights.clear(); // Overwrite the existing entries each time this is called. - for (Map.Entry e : weights.entrySet()) { - this.weights.put(e.getKey(), new Float[]{e.getValue()}); - } - return this; - } - - public TargetsBuilder weightsMulti(Map weights) { - this.weights = weights; - return this; - } - } -} - diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/argument/WhereArgument.java b/src/main/java/io/weaviate/client/v1/graphql/query/argument/WhereArgument.java deleted file mode 100644 index e9cbae2bd..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/argument/WhereArgument.java +++ /dev/null @@ -1,100 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.commons.lang3.time.DateFormatUtils; - -import java.util.LinkedHashSet; -import java.util.Objects; -import java.util.Set; -import java.util.function.Function; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class WhereArgument implements Argument { - - WhereFilter filter; - - @Override - public String build() { - String whereStr = filter != null ? buildNestedFilter(filter) : ""; - return String.format("where:{%s}", whereStr); - } - - private String buildNestedFilter(WhereFilter f) { - Set args = new LinkedHashSet<>(); - - if (ArrayUtils.isNotEmpty(f.getOperands())) { - if (f.getOperator() != null) { - args.add(buildArg("operator", Serializer.escape(f.getOperator()))); - } - args.add(buildArg("operands", Serializer.array(f.getOperands(), o -> String.format("{%s}", buildNestedFilter(o))))); - } else { - if (ArrayUtils.isNotEmpty(f.getPath())) { - args.add(buildArg("path", Serializer.arrayWithQuotes(f.getPath()))); - } - addArgSingleOrArray("valueBoolean", f.getValueBoolean(), f.getValueBooleanArray(), args::add); - addArgSingleOrArray("valueInt", f.getValueInt(), f.getValueIntArray(), args::add); - addArgSingleOrArray("valueNumber", f.getValueNumber(), f.getValueNumberArray(), args::add); - addArgSingleOrArray("valueString", f.getValueString(), f.getValueStringArray(), args::add, Serializer::quote); - addArgSingleOrArray("valueText", f.getValueText(), f.getValueTextArray(), args::add, Serializer::quote); - addArgSingleOrArray("valueDate", f.getValueDate(), f.getValueDateArray(), args::add, date -> { - String dateString = DateFormatUtils.format(date, "yyyy-MM-dd'T'HH:mm:ssZZZZZ"); - return Serializer.quote(dateString); - }); - - if (f.getValueGeoRange() != null) { - args.add(buildArg("valueGeoRange", buildGeoRange(f.getValueGeoRange()))); - } - if (f.getOperator() != null) { - args.add(buildArg("operator", Serializer.escape(f.getOperator()))); - } - } - - return String.join(" ", args); - } - - private String buildGeoRange(WhereFilter.GeoRange geoRange) { - WhereFilter.GeoCoordinates geoCoordinates = geoRange.getGeoCoordinates(); - WhereFilter.GeoDistance distance = geoRange.getDistance(); - if (ObjectUtils.allNotNull(geoCoordinates, geoCoordinates.getLatitude(), geoCoordinates.getLongitude(), - distance, distance.getMax()) - ) { - return String.format("{geoCoordinates:{latitude:%s,longitude:%s},distance:{max:%s}}", - geoCoordinates.getLatitude(), geoCoordinates.getLongitude(), distance.getMax()); - } - return ""; - } - - private String buildArg(String name, Object value) { - return String.format("%s:%s", name, value); - } - - private void addArgSingleOrArray(String valueName, T value, T[] values, Function add, - Function valueMapper) { - String valAsString = null; - if (Objects.nonNull(value)) { - valAsString = valueMapper.apply(value); - } else if (ArrayUtils.isNotEmpty(values)) { - valAsString = Serializer.array(values, valueMapper); - } - if (Objects.nonNull(valAsString)) { - add.apply(buildArg(valueName, valAsString)); - } - } - - private void addArgSingleOrArray(String valueName, T value, T[] values, Function add) { - addArgSingleOrArray(valueName, value, values, add, Objects::toString); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilder.java b/src/main/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilder.java deleted file mode 100644 index e2ccdfd9c..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilder.java +++ /dev/null @@ -1,125 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.query.argument.Argument; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.StringUtils; - -import java.util.LinkedHashSet; -import java.util.Objects; -import java.util.Set; -import java.util.stream.Stream; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class AggregateBuilder implements Query { - String className; - Fields fields; - String groupByClausePropertyName; - WhereArgument withWhereFilter; - AskArgument withAskArgument; - NearTextArgument withNearTextFilter; - NearObjectArgument withNearObjectFilter; - NearVectorArgument withNearVectorFilter; - NearImageArgument withNearImageFilter; - NearAudioArgument withNearAudioFilter; - NearVideoArgument withNearVideoFilter; - NearDepthArgument withNearDepthFilter; - NearThermalArgument withNearThermalFilter; - NearImuArgument withNearImuFilter; - Integer objectLimit; - Integer limit; - String tenant; - - private Stream buildableArguments() { - return Stream.of(withWhereFilter, withAskArgument, withNearTextFilter, withNearObjectFilter, - withNearVectorFilter, withNearImageFilter, withNearAudioFilter, withNearVideoFilter, withNearDepthFilter, - withNearThermalFilter, withNearImuFilter); - } - - private Stream nonStringArguments() { - return Stream.of(objectLimit, limit); - } - - private Stream stringArguments() { - return Stream.of(groupByClausePropertyName, tenant); - } - - private boolean includesFilterClause() { - return buildableArguments().anyMatch(Objects::nonNull) - || nonStringArguments().anyMatch(Objects::nonNull) - || stringArguments().anyMatch(StringUtils::isNotBlank); - } - - private String createFilterClause() { - if (includesFilterClause()) { - Set filters = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(tenant)) { - filters.add(String.format("tenant:%s", Serializer.quote(tenant))); - } - if (StringUtils.isNotBlank(groupByClausePropertyName)) { - filters.add(String.format("groupBy:%s", Serializer.quote(groupByClausePropertyName))); - } - - buildableArguments() - .filter(Objects::nonNull) - .map(Argument::build) - .forEach(filters::add); - - if (limit != null) { - filters.add(String.format("limit:%s", limit)); - } - if (objectLimit != null) { - filters.add(String.format("objectLimit:%s", objectLimit)); - } - - return String.format("(%s)", String.join(" ", filters)); - } - return ""; - } - - @Override - public String buildQuery() { - String fieldsClause = fields != null ? fields.build() : ""; - return String.format("{Aggregate{%s%s{%s}}}", Serializer.escape(className), createFilterClause(), fieldsClause); - } - - - // created to support both types of setters: WhereArgument and deprecated WhereFilter - public static class AggregateBuilderBuilder { - private WhereArgument withWhereFilter; - - @Deprecated - public AggregateBuilderBuilder withWhereFilter(WhereFilter whereFilter) { - this.withWhereFilter = WhereArgument.builder().filter(whereFilter).build(); - return this; - } - - public AggregateBuilderBuilder withWhereFilter(WhereArgument whereArgument) { - this.withWhereFilter = whereArgument; - return this; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilder.java b/src/main/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilder.java deleted file mode 100644 index 5b731cb5f..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilder.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import io.weaviate.client.v1.graphql.query.argument.Argument; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; - -import java.util.LinkedHashSet; -import java.util.Objects; -import java.util.Set; -import java.util.stream.Stream; - -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.v1.graphql.model.ExploreFields; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ExploreBuilder implements Query { - ExploreFields[] fields; - Integer offset; - Integer limit; - AskArgument withAskArgument; - NearTextArgument withNearText; - NearObjectArgument withNearObjectFilter; - NearVectorArgument withNearVectorFilter; - NearImageArgument withNearImageFilter; - NearAudioArgument withNearAudioFilter; - NearVideoArgument withNearVideoFilter; - NearDepthArgument withNearDepthFilter; - NearThermalArgument withNearThermalFilter; - NearImuArgument withNearImuFilter; - - private String createFilterClause() { - Set filters = new LinkedHashSet<>(); - - Stream.of(withAskArgument, withNearText, withNearObjectFilter, withNearVectorFilter, withNearImageFilter, - withNearAudioFilter, withNearVideoFilter, withNearDepthFilter, withNearThermalFilter, withNearImuFilter) - .filter(Objects::nonNull) - .map(Argument::build) - .forEach(filters::add); - - if (limit != null) { - filters.add(String.format("limit:%s", limit)); - } - if (offset != null) { - filters.add(String.format("offset:%s", offset)); - } - - return String.format("%s", String.join(" ", filters)); - } - - @Override - public String buildQuery() { - String fieldsClause = ""; - if (ArrayUtils.isNotEmpty(fields)) { - fieldsClause = StringUtils.joinWith(",", (Object[]) fields); - } - String filterClause = createFilterClause(); - return String.format("{Explore(%s){%s}}", filterClause, fieldsClause); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/builder/GetBuilder.java b/src/main/java/io/weaviate/client/v1/graphql/query/builder/GetBuilder.java deleted file mode 100644 index a4669958a..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/builder/GetBuilder.java +++ /dev/null @@ -1,374 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Optional; -import java.util.Set; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.ObjectUtils; -import org.apache.commons.lang3.StringUtils; - -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.MetadataRequest; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.PropertiesRequest; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.query.argument.Argument; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArguments; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder; -import io.weaviate.client.v1.graphql.query.util.Serializer; -import io.weaviate.client.v1.grpc.GRPC; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class GetBuilder implements Query { - String className; - Fields fields; - Integer offset; - Integer limit; - String after; - Integer autocut; - String withConsistencyLevel; - WhereArgument withWhereFilter; - Bm25Argument withBm25Filter; - HybridArgument withHybridFilter; - AskArgument withAskArgument; - NearTextArgument withNearTextFilter; - NearObjectArgument withNearObjectFilter; - NearVectorArgument withNearVectorFilter; - NearImageArgument withNearImageFilter; - NearAudioArgument withNearAudioFilter; - NearVideoArgument withNearVideoFilter; - NearDepthArgument withNearDepthFilter; - NearThermalArgument withNearThermalFilter; - NearImuArgument withNearImuFilter; - GroupArgument withGroupArgument; - SortArguments withSortArguments; - GenerativeSearchBuilder withGenerativeSearch; - GroupByArgument withGroupByArgument; - String tenant; - - private Stream buildableArguments() { - return Stream.of(withWhereFilter, withAskArgument, withNearTextFilter, withNearObjectFilter, - withNearVectorFilter, withGroupArgument, withBm25Filter, withHybridFilter, withSortArguments, - withGroupByArgument, - withNearImageFilter, withNearAudioFilter, withNearVideoFilter, withNearDepthFilter, withNearThermalFilter, - withNearImuFilter); - } - - private Stream nonStringArguments() { - return Stream.of(limit, offset, autocut); - } - - private Stream stringArguments() { - return Stream.of(withConsistencyLevel, after, tenant); - } - - private boolean includesFilterClause() { - return buildableArguments().anyMatch(Objects::nonNull) - || nonStringArguments().anyMatch(Objects::nonNull) - || stringArguments().anyMatch(StringUtils::isNotBlank); - } - - private String createFilterClause() { - if (includesFilterClause()) { - Set filters = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(tenant)) { - filters.add(String.format("tenant:%s", Serializer.quote(tenant))); - } - - buildableArguments() - .filter(Objects::nonNull) - .map(Argument::build) - .forEach(filters::add); - - if (limit != null) { - filters.add(String.format("limit:%s", limit)); - } - if (offset != null) { - filters.add(String.format("offset:%s", offset)); - } - if (StringUtils.isNotBlank(after)) { - filters.add(String.format("after:%s", Serializer.quote(after))); - } - if (StringUtils.isNotBlank(withConsistencyLevel)) { - filters.add(String.format("consistencyLevel:%s", Serializer.escape(withConsistencyLevel))); - } - if (autocut != null) { - filters.add(String.format("autocut:%s", autocut)); - } - - return String.format("(%s)", String.join(" ", filters)); - } - return ""; - } - - private String createFields() { - if (ObjectUtils.allNull(fields, withGenerativeSearch)) { - return ""; - } - - if (withGenerativeSearch == null) { - return fields.build(); - } - - Field generate = withGenerativeSearch.build(); - Field generateAdditional = Field.builder() - .name("_additional") - .fields(new Field[] { generate }) - .build(); - - if (fields == null) { - return generateAdditional.build(); - } - - // check if _additional field exists. If missing just add new _additional with - // generate, - // if exists merge generate into present one - Map> grouped = Arrays.stream(fields.getFields()) - .collect(Collectors.groupingBy(f -> "_additional".equals(f.getName()))); - - List additionals = grouped.getOrDefault(true, new ArrayList<>()); - if (additionals.isEmpty()) { - additionals.add(generateAdditional); - } else { - Field[] mergedInternalFields = Stream.concat( - Arrays.stream(additionals.get(0).getFields()), - Stream.of(generate)).toArray(Field[]::new); - - additionals.set(0, Field.builder() - .name("_additional") - .fields(mergedInternalFields) - .build()); - } - - Field[] allFields = Stream.concat( - grouped.getOrDefault(false, new ArrayList<>()).stream(), - additionals.stream()).toArray(Field[]::new); - - return Fields.builder() - .fields(allFields) - .build() - .build(); - } - - @Override - public String buildQuery() { - return String.format("{Get{%s%s{%s}}}", Serializer.escape(className), createFilterClause(), createFields()); - } - - public SearchRequest buildSearchRequest() { - SearchRequest.Builder search = SearchRequest.newBuilder(); - - search.setCollection(this.className); - - if (StringUtils.isNotBlank(tenant)) { - search.setTenant(this.tenant); - } - - if (this.withWhereFilter != null) { - Filters.Builder filters = Filters.newBuilder(); - addWhereFilters(filters, this.withWhereFilter.getFilter()); - search.setFilters(filters.build()); - } - - if (this.withNearVectorFilter != null) { - NearVector.Builder nearVector = NearVector.newBuilder(); - NearVectorArgument f = this.withNearVectorFilter; - - Float[] vector = f.getVector(); - if (vector != null) { - nearVector.setVectorBytes(GRPC.toByteString(f.getVector())); - } - - if (f.getCertainty() != null) { - nearVector.setCertainty(f.getCertainty()); - } else if (f.getDistance() != null) { - nearVector.setDistance(f.getDistance()); - } - - search.setNearVector(nearVector.build()); - } - - if (limit != null) { - search.setLimit(limit); - } - if (offset != null) { - search.setOffset(offset); - } - if (StringUtils.isNotBlank(after)) { - search.setAfter(after); - } - if (StringUtils.isNotBlank(withConsistencyLevel)) { - search.setConsistencyLevelValue(Integer.valueOf(withConsistencyLevel)); - } - if (autocut != null) { - search.setAutocut(autocut); - } - - if (fields != null) { - - // Metadata - Optional _additional = Arrays.stream(fields.getFields()) - .filter(f -> "_additional".equals(f.getName())).findFirst(); - if (_additional.isPresent()) { - MetadataRequest.Builder metadata = MetadataRequest.newBuilder(); - for (Field f : _additional.get().getFields()) { - switch (f.getName()) { - case "id": - metadata.setUuid(true); - break; - case "vector": - metadata.setVector(true); - break; - case "distance": - metadata.setDistance(true); - break; - } - } - search.setMetadata(metadata.build()); - } - - // Properties - List props = Arrays.stream(fields.getFields()) - .filter(f -> !"_additional".equals(f.getName())).collect(Collectors.toList()); - if (!props.isEmpty()) { - PropertiesRequest.Builder properties = PropertiesRequest.newBuilder(); - for (Field f : props) { - properties.addNonRefProperties(f.getName()); - } - search.setProperties(properties.build()); - } - } - - search.setUses123Api(true); - search.setUses125Api(true); - search.setUses127Api(true); - return search.build(); - } - - private void addWhereFilters(Filters.Builder where, WhereFilter f) { - WhereFilter[] operands = f.getOperands(); - - if (ArrayUtils.isNotEmpty(operands)) { // Nested filters - for (WhereFilter op : operands) { - Filters.Builder nested = Filters.newBuilder(); - addWhereFilters(nested, op); - where.addFilters(nested); - // addWhereFilters(where, op); - } - } else { // Individual where clauses (leaves) - if (ArrayUtils.isNotEmpty(f.getPath())) { - // Deprecated, but the current proto doesn't have 'path'. - where.addOn(f.getPath()[0]); - } - if (f.getValueBoolean() != null) { - } else if (f.getValueBooleanArray() != null) { - BooleanArray.Builder arr = BooleanArray.newBuilder(); - Arrays.stream(f.getValueBooleanArray()).forEach(v -> arr.addValues(v)); - where.setValueBooleanArray(arr.build()); - } else if (f.getValueInt() != null) { - where.setValueInt(f.getValueInt()); - } else if (f.getValueIntArray() != null) { - IntArray.Builder arr = IntArray.newBuilder(); - Arrays.stream(f.getValueIntArray()).forEach(v -> arr.addValues(v)); - where.setValueIntArray(arr); - } else if (f.getValueNumber() != null) { - where.setValueNumber(f.getValueNumber()); - } else if (f.getValueNumberArray() != null) { - NumberArray.Builder arr = NumberArray.newBuilder(); - Arrays.stream(f.getValueNumberArray()).forEach(v -> arr.addValues(v)); - where.setValueNumberArray(arr); - } else if (f.getValueText() != null) { - where.setValueText(f.getValueText()); - } else if (f.getValueTextArray() != null) { - TextArray.Builder arr = TextArray.newBuilder(); - Arrays.stream(f.getValueTextArray()).forEach(v -> arr.addValues(v)); - where.setValueTextArray(arr); - } else if (f.getValueString() != null) { - where.setValueText(f.getValueString()); - } else if (f.getValueStringArray() != null) { - TextArray.Builder arr = TextArray.newBuilder(); - Arrays.stream(f.getValueStringArray()).forEach(v -> arr.addValues(v)); - where.setValueTextArray(arr); - } else { - assert false : "unexpected WhereFilter value"; - } - } - - switch (f.getOperator()) { - case Operator.And: - where.setOperator(WeaviateProtoBase.Filters.Operator.OPERATOR_AND); - break; - case Operator.Or: - where.setOperator(WeaviateProtoBase.Filters.Operator.OPERATOR_OR); - break; - case Operator.Equal: - where.setOperator(WeaviateProtoBase.Filters.Operator.OPERATOR_EQUAL); - break; - case Operator.NotEqual: - where.setOperator(WeaviateProtoBase.Filters.Operator.OPERATOR_NOT_EQUAL); - break; - default: - assert false : "unexpected operator: " + f.getOperator(); - } - } - - // created to support both types of setters: WhereArgument and deprecated - // WhereFilter - public static class GetBuilderBuilder { - private WhereArgument withWhereFilter; - - @Deprecated - public GetBuilderBuilder withWhereFilter(WhereFilter whereFilter) { - this.withWhereFilter = WhereArgument.builder().filter(whereFilter).build(); - return this; - } - - public GetBuilderBuilder withWhereFilter(WhereArgument whereArgument) { - this.withWhereFilter = whereArgument; - return this; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/builder/Query.java b/src/main/java/io/weaviate/client/v1/graphql/query/builder/Query.java deleted file mode 100644 index 762c38e27..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/builder/Query.java +++ /dev/null @@ -1,5 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -public interface Query { - String buildQuery(); -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/fields/Field.java b/src/main/java/io/weaviate/client/v1/graphql/query/fields/Field.java deleted file mode 100644 index bd6871d9d..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/fields/Field.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import io.weaviate.client.v1.graphql.query.argument.Argument; -import java.util.Arrays; -import java.util.stream.Collectors; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Field implements Argument { - String name; - Field[] fields; - - @Override - public String build() { - StringBuilder s = new StringBuilder(); - if (StringUtils.isNotBlank(name)) { - s.append(name); - } - if (ArrayUtils.isNotEmpty(fields)) { - s.append(String.format("{%s}", Arrays.stream(fields).map(Field::build).collect(Collectors.joining(" ")))); - } - return s.toString(); - } - - - // created to accept a variable number of fields - public static class FieldBuilder { - private Field[] fields; - - public FieldBuilder fields(Field... fields) { - this.fields = fields; - return this; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/fields/Fields.java b/src/main/java/io/weaviate/client/v1/graphql/query/fields/Fields.java deleted file mode 100644 index 6b2086e21..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/fields/Fields.java +++ /dev/null @@ -1,43 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ObjectUtils; -import io.weaviate.client.v1.graphql.query.argument.Argument; - -import java.util.Arrays; -import java.util.stream.Collectors; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Fields implements Argument { - Field[] fields; - - @Override - public String build() { - if (ObjectUtils.isEmpty(fields)) { - return ""; - } - return Arrays.stream(fields) - .map(Field::build) - .collect(Collectors.joining(" ")); - } - - - // created to accept a variable number of fields - public static class FieldsBuilder { - private Field[] fields; - - public FieldsBuilder fields(Field... fields) { - this.fields = fields; - return this; - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilder.java b/src/main/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilder.java deleted file mode 100644 index cd2b3e7ce..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilder.java +++ /dev/null @@ -1,59 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import io.weaviate.client.v1.graphql.query.util.Serializer; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.StringUtils; - -import java.util.LinkedHashSet; -import java.util.Set; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class GenerativeSearchBuilder { - - String singleResultPrompt; - String groupedResultTask; - String[] groupedResultProperties; - - public Field build() { - Set nameParts = new LinkedHashSet<>(); - Set fieldNames = new LinkedHashSet<>(); - - if (StringUtils.isNotBlank(singleResultPrompt)) { - nameParts.add(String.format("singleResult:{prompt:\"\"%s\"\"}", Serializer.quote(singleResultPrompt))); - fieldNames.add("singleResult"); - } - if (StringUtils.isNotBlank(groupedResultTask) || ArrayUtils.isNotEmpty(groupedResultProperties)) { - Set argParts = new LinkedHashSet<>(); - if (StringUtils.isNotBlank(groupedResultTask)) { - argParts.add(String.format("task:\"\"%s\"\"", Serializer.quote(groupedResultTask))); - } - if (ArrayUtils.isNotEmpty(groupedResultProperties)) { - argParts.add(String.format("properties:%s", Serializer.arrayWithQuotes(groupedResultProperties))); - } - nameParts.add(String.format("groupedResult:{%s}", StringUtils.join(argParts, " "))); - fieldNames.add("groupedResult"); - } - - if (nameParts.isEmpty()) { - return Field.builder().build(); - } - - fieldNames.add("error"); - String name = String.format("generate(%s)", String.join(" ", nameParts)); - Field[] fields = fieldNames.stream() - .map(n -> Field.builder().name(n).build()) - .toArray(Field[]::new); - - return Field.builder().name(name).fields(fields).build(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/graphql/query/util/Serializer.java b/src/main/java/io/weaviate/client/v1/graphql/query/util/Serializer.java deleted file mode 100644 index b15a6f44c..000000000 --- a/src/main/java/io/weaviate/client/v1/graphql/query/util/Serializer.java +++ /dev/null @@ -1,91 +0,0 @@ -package io.weaviate.client.v1.graphql.query.util; - -import java.util.Arrays; -import java.util.function.Function; -import java.util.stream.Collectors; -import org.apache.commons.lang3.StringEscapeUtils; -import org.apache.commons.lang3.StringUtils; - -public class Serializer { - - private Serializer() { - } - - /** - * Creates graphql safe string - * Nested quotes are escaped - * - * @param input string - * @return escaped string - */ - public static String escape(String input) { - if (input == null) { - return ""; - } - return StringEscapeUtils.escapeJava(input); - } - - /** - * Creates graphql safe string - * Surrounds input string with double quotes, nested quotes are escaped - * - * @param input string - * @return quoted string - */ - public static String quote(String input) { - if (input == null) { - return ""; - } - if (input.equals("")) { - return "\"\""; - } - return StringUtils.wrap(escape(input), "\""); - } - - /** - * Creates json safe array string - * Surrounds each input string with double quotes, nested quotes are escaped - * - * @param input array of strings - * @return json safe array string - */ - public static String arrayWithQuotes(String[] input) { - return array(input, Serializer::quote); - } - - /** - * Creates array string - * It is up to user to make elements json safe - * - * @param input array of arbitrary elements - * @return array string - */ - public static String array(T[] input) { - return array(input, i -> i); - } - - /** - * Creates array string - * It is up to user to make elements json safe - * - * @param input array of arbitrary elements - * @param mapper maps single element before building array - * @return array string - */ - public static String array(T[] input, Function mapper) { - String inner = ""; - if (input != null) { - inner = Arrays.stream(input) - .map(mapper) - .map(obj -> { - if (obj.getClass().isArray()) { - return array((Object[]) obj); - } - return obj.toString(); - }) - .collect(Collectors.joining(",")); - } - - return "[" + inner + "]"; - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/Groups.java b/src/main/java/io/weaviate/client/v1/groups/Groups.java deleted file mode 100644 index a78f4747b..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/Groups.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.groups; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; - -public class Groups { - private final Config config; - private final HttpClient httpClient; - - public Groups(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public OidcGroups oidc() { - return new OidcGroups(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/OidcGroups.java b/src/main/java/io/weaviate/client/v1/groups/OidcGroups.java deleted file mode 100644 index 4165c00c9..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/OidcGroups.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.groups; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.groups.api.oidc.AssignedRolesGetter; -import io.weaviate.client.v1.groups.api.oidc.KnownGroupNamesGetter; -import io.weaviate.client.v1.groups.api.oidc.RoleAssigner; -import io.weaviate.client.v1.groups.api.oidc.RoleRevoker; - -public class OidcGroups { - private final Config config; - private final HttpClient httpClient; - - public OidcGroups(HttpClient httpClient, Config config) { - this.config = config; - this.httpClient = httpClient; - } - - public RoleAssigner roleAssigner() { - return new RoleAssigner(httpClient, config); - } - - public RoleRevoker roleRevoker() { - return new RoleRevoker(httpClient, config); - } - - public AssignedRolesGetter assignedRolesGetter() { - return new AssignedRolesGetter(httpClient, config); - } - - public KnownGroupNamesGetter knownGroupNamesGetter() { - return new KnownGroupNamesGetter(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/api/oidc/AssignedRolesGetter.java b/src/main/java/io/weaviate/client/v1/groups/api/oidc/AssignedRolesGetter.java deleted file mode 100644 index 0333f54cc..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/api/oidc/AssignedRolesGetter.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.groups.api.oidc; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class AssignedRolesGetter extends BaseClient implements ClientResult> { - private String groupId; - private boolean includePermissions = false; - - public AssignedRolesGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AssignedRolesGetter withGroupId(String id) { - this.groupId = id; - return this; - } - - public AssignedRolesGetter includePermissions(boolean include) { - this.includePermissions = include; - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - @Override - public Result> run() { - return Result.toList(sendGetRequest(path(), WeaviateRole[].class), WeaviateRole::toRole); - } - - private String path() { - return String.format("/authz/groups/%s/roles/oidc?includeFullRoles=%s", encodeGroupId(), includePermissions); - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/api/oidc/KnownGroupNamesGetter.java b/src/main/java/io/weaviate/client/v1/groups/api/oidc/KnownGroupNamesGetter.java deleted file mode 100644 index 412869a92..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/api/oidc/KnownGroupNamesGetter.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.groups.api.oidc; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.aliases.model.Alias; - -public class KnownGroupNamesGetter extends BaseClient implements ClientResult> { - - public KnownGroupNamesGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - static class ResponseBody { - List aliases; - } - - @Override - public Result> run() { - return Result.toList(sendGetRequest("/authz/groups/oidc", String[].class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleAssigner.java b/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleAssigner.java deleted file mode 100644 index 905221069..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleAssigner.java +++ /dev/null @@ -1,56 +0,0 @@ -package io.weaviate.client.v1.groups.api.oidc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AllArgsConstructor; - -public class RoleAssigner extends BaseClient implements ClientResult { - private String groupId; - private List roles = new ArrayList<>(); - - public RoleAssigner(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public RoleAssigner withGroupId(String id) { - this.groupId = id; - return this; - } - - public RoleAssigner witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - @SerializedName("roles") - final List roles; - @SerializedName("groupType") - final String groupType = "oidc"; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest(path(), new Body(this.roles), Void.class)); - } - - private String path() { - return String.format("/authz/groups/%s/assign", encodeGroupId()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleRevoker.java b/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleRevoker.java deleted file mode 100644 index abed29db5..000000000 --- a/src/main/java/io/weaviate/client/v1/groups/api/oidc/RoleRevoker.java +++ /dev/null @@ -1,56 +0,0 @@ -package io.weaviate.client.v1.groups.api.oidc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import lombok.AllArgsConstructor; - -public class RoleRevoker extends BaseClient implements ClientResult { - private String groupId; - private List roles = new ArrayList<>(); - - public RoleRevoker(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public RoleRevoker withGroupId(String id) { - this.groupId = id; - return this; - } - - public RoleRevoker witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - private String encodeGroupId() { - return UrlEncoder.encode(this.groupId); - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - @SerializedName("roles") - final List roles; - @SerializedName("groupType") - final String groupType = "oidc"; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest(path(), new Body(this.roles), Void.class)); - } - - private String path() { - return String.format("/authz/groups/%s/revoke", encodeGroupId()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/grpc/GRPC.java b/src/main/java/io/weaviate/client/v1/grpc/GRPC.java deleted file mode 100644 index 3ddcf8853..000000000 --- a/src/main/java/io/weaviate/client/v1/grpc/GRPC.java +++ /dev/null @@ -1,123 +0,0 @@ -package io.weaviate.client.v1.grpc; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.FloatBuffer; -import java.util.Arrays; - -import org.apache.commons.lang3.ArrayUtils; - -import com.google.protobuf.ByteString; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.grpc.query.Raw; - -public class GRPC { - private static final ByteOrder BYTE_ORDER = ByteOrder.LITTLE_ENDIAN; - - private Config config; - private HttpClient httpClient; - private AccessTokenProvider tokenProvider; - - public static class Arguments { - public NearVectorArgument.NearVectorArgumentBuilder nearVectorArgBuilder() { - return NearVectorArgument.builder(); - } - } - - public GRPC(HttpClient httpClient, Config config, AccessTokenProvider tokenProvider) { - this.config = config; - this.httpClient = httpClient; - this.tokenProvider = tokenProvider; - } - - public Raw raw() { - return new Raw(httpClient, config, tokenProvider); - } - - public GRPC.Arguments arguments() { - return new GRPC.Arguments(); - } - - /** Encode Float[] to ByteString. */ - public static ByteString toByteString(Float[] vector) { - if (vector == null || vector.length == 0) { - return ByteString.EMPTY; - } - ByteBuffer buffer = ByteBuffer.allocate(vector.length * Float.BYTES).order(BYTE_ORDER); - Arrays.stream(vector).forEach(buffer::putFloat); - return ByteString.copyFrom(buffer.array()); - } - - /** Encode float[] to ByteString. */ - public static ByteString toByteString(float[] vector) { - ByteBuffer buffer = ByteBuffer.allocate(vector.length * Float.BYTES).order(BYTE_ORDER); - for (float f : vector) { - buffer.putFloat(f); - } - return ByteString.copyFrom(buffer.array()); - } - - /** - * Encode Float[][] to ByteString. - *

- * The first 2 bytes of the resulting ByteString encode the number of dimensions - * (uint16 / short) followed by concatenated vectors (4 bytes per element). - */ - public static ByteString toByteString(Float[][] vectors) { - if (vectors == null || vectors.length == 0 || vectors[0].length == 0) { - return ByteString.EMPTY; - } - - int n = vectors.length; - short dimensions = (short) vectors[0].length; - int capacity = /* vector dimensions */ Short.BYTES + - /* concatenated elements */ (n * dimensions * Float.BYTES); - ByteBuffer buffer = ByteBuffer.allocate(capacity).order(BYTE_ORDER) - .putShort(dimensions); - Arrays.stream(vectors).forEach(v -> Arrays.stream(v).forEach(buffer::putFloat)); - return ByteString.copyFrom(buffer.array()); - } - - /** - * Decode ByteString into a Float[]. ByteString size must be a multiple of - * {@link Float#BYTES}, throws {@link IllegalArgumentException} otherwise. - */ - public static Float[] fromByteString(ByteString bs) { - if (bs.size() % Float.BYTES != 0) { - throw new IllegalArgumentException( - "byte string size not a multiple of " + String.valueOf(Float.BYTES) + " (Float.BYTES)"); - } - float[] vector = new float[bs.size() / Float.BYTES]; - bs.asReadOnlyByteBuffer().order(BYTE_ORDER).asFloatBuffer().get(vector); - return ArrayUtils.toObject(vector); - } - - /** Decode ByteString into a Float[][]. */ - public static Float[][] fromByteStringMulti(ByteString bs) { - if (bs == null || bs.size() == 0) { - return new Float[0][0]; - } - - ByteBuffer buf = bs.asReadOnlyByteBuffer().order(BYTE_ORDER); - - // Dimensions are encoded in the first 2 bytes. - short dimensions = buf.getShort(); // advances current position - - FloatBuffer fbuf = buf.asFloatBuffer(); - int n = fbuf.remaining() / dimensions; // fbuf size is buf / Float.BYTES - - // Reading from buffer advances current position, - // so we always read from offset=0. - Float[][] vectors = new Float[n][dimensions]; - for (int i = 0; i < n; i++) { - float[] v = new float[dimensions]; - fbuf.get(v, 0, dimensions); - vectors[i] = ArrayUtils.toObject(v); - } - return vectors; - } -} diff --git a/src/main/java/io/weaviate/client/v1/grpc/query/Raw.java b/src/main/java/io/weaviate/client/v1/grpc/query/Raw.java deleted file mode 100644 index 11c35d1c5..000000000 --- a/src/main/java/io/weaviate/client/v1/grpc/query/Raw.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.v1.grpc.query; - -import java.util.Map; - -import io.weaviate.client.Config; -import io.weaviate.client.base.grpc.GrpcClient; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchReply; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoSearchGet.SearchRequest; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.experimental.SearchClient; -import io.weaviate.client.v1.experimental.SearchResult; - -public class Raw { - private final AccessTokenProvider tokenProvider; - private final Config config; - private SearchRequest search; - - public Raw(HttpClient httpClient, Config config, AccessTokenProvider tokenProvider) { - this.config = config; - this.tokenProvider = tokenProvider; - } - - public Raw withSearch(SearchRequest search) { - this.search = search; - return this; - } - - public SearchResult> run() { - GrpcClient grpcClient = GrpcClient.create(this.config, this.tokenProvider); - try { - SearchReply reply = grpcClient.search(this.search); - return SearchClient.deserializeUntyped(reply); - } finally { - grpcClient.shutdown(); - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/Misc.java b/src/main/java/io/weaviate/client/v1/misc/Misc.java deleted file mode 100644 index e4a580b12..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/Misc.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.misc; - -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionProvider; -import io.weaviate.client.v1.misc.api.LiveChecker; -import io.weaviate.client.v1.misc.api.MetaGetter; -import io.weaviate.client.v1.misc.api.OpenIDConfigGetter; -import io.weaviate.client.v1.misc.api.ReadyChecker; -import io.weaviate.client.Config; - -public class Misc { - private final Config config; - private final DbVersionProvider dbVersionProvider; - private final HttpClient httpClient; - - public Misc(HttpClient httpClient, Config config, DbVersionProvider dbVersionProvider) { - this.httpClient = httpClient; - this.config = config; - this.dbVersionProvider = dbVersionProvider; - } - - public MetaGetter metaGetter() { - return new MetaGetter(httpClient, config); - } - - public OpenIDConfigGetter openIDConfigGetter() { - return new OpenIDConfigGetter(httpClient, config); - } - - public LiveChecker liveChecker() { - return new LiveChecker(httpClient, config, dbVersionProvider); - } - - public ReadyChecker readyChecker() { - return new ReadyChecker(httpClient, config, dbVersionProvider); - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/api/LiveChecker.java b/src/main/java/io/weaviate/client/v1/misc/api/LiveChecker.java deleted file mode 100644 index 382916642..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/api/LiveChecker.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionProvider; - -public class LiveChecker extends BaseClient implements ClientResult { - - private final DbVersionProvider dbVersionProvider; - - public LiveChecker(HttpClient httpClient, Config config, DbVersionProvider dbVersionProvider) { - super(httpClient, config); - this.dbVersionProvider = dbVersionProvider; - } - - @Override - public Result run() { - Response resp = sendGetRequest("/.well-known/live", String.class); - if (resp.getStatusCode() == 200) { - dbVersionProvider.refresh(); - } - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/api/MetaGetter.java b/src/main/java/io/weaviate/client/v1/misc/api/MetaGetter.java deleted file mode 100644 index 0bbf3b40d..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/api/MetaGetter.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.misc.api; - -import io.weaviate.client.v1.misc.model.Meta; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class MetaGetter extends BaseClient implements ClientResult { - - public MetaGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result run() { - Response resp = sendGetRequest("/meta", Meta.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/api/OpenIDConfigGetter.java b/src/main/java/io/weaviate/client/v1/misc/api/OpenIDConfigGetter.java deleted file mode 100644 index bcaa2341a..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/api/OpenIDConfigGetter.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.misc.api; - -import io.weaviate.client.v1.misc.model.OpenIDConfiguration; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class OpenIDConfigGetter extends BaseClient implements ClientResult { - - public OpenIDConfigGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result run() { - Response resp = sendGetRequest("/.well-known/openid-configuration", OpenIDConfiguration.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/api/ReadyChecker.java b/src/main/java/io/weaviate/client/v1/misc/api/ReadyChecker.java deleted file mode 100644 index 1f6e3a2e8..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/api/ReadyChecker.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.misc.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionProvider; - -public class ReadyChecker extends BaseClient implements ClientResult { - - private final DbVersionProvider dbVersionProvider; - - public ReadyChecker(HttpClient httpClient, Config config, DbVersionProvider dbVersionProvider) { - super(httpClient, config); - this.dbVersionProvider = dbVersionProvider; - } - - @Override - public Result run() { - Response resp = sendGetRequest("/.well-known/ready", String.class); - if (resp.getStatusCode() == 200) { - dbVersionProvider.refresh(); - } - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/BM25Config.java b/src/main/java/io/weaviate/client/v1/misc/model/BM25Config.java deleted file mode 100644 index 7f13bdb63..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/BM25Config.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Builder -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class BM25Config { - Float k1; - Float b; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/BQConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/BQConfig.java deleted file mode 100644 index 4e7c5417a..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/BQConfig.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class BQConfig { - Boolean enabled; - Long rescoreLimit; - Boolean cache; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/DistanceType.java b/src/main/java/io/weaviate/client/v1/misc/model/DistanceType.java deleted file mode 100644 index 80e53cdd7..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/DistanceType.java +++ /dev/null @@ -1,10 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -public interface DistanceType { - - String COSINE = "cosine"; - String DOT = "dot"; - String L2_SQUARED = "l2-squared"; - String HAMMING = "hamming"; - String MANHATTAN = "manhattan"; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/InvertedIndexConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/InvertedIndexConfig.java deleted file mode 100644 index 10089fdff..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/InvertedIndexConfig.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class InvertedIndexConfig { - BM25Config bm25; - StopwordConfig stopwords; - Integer cleanupIntervalSeconds; - Boolean indexTimestamps; - Boolean indexNullState; - Boolean indexPropertyLength; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/Meta.java b/src/main/java/io/weaviate/client/v1/misc/model/Meta.java deleted file mode 100644 index 231d3e05d..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/Meta.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class Meta { - String hostname; - String version; - Object modules; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MultiTenancyConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MultiTenancyConfig.java deleted file mode 100644 index b9331263f..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/MultiTenancyConfig.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class MultiTenancyConfig { - Boolean enabled; - Boolean autoTenantCreation; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java deleted file mode 100644 index 11fdb1a04..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/MultiVectorConfig.java +++ /dev/null @@ -1,52 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class MultiVectorConfig { - @Builder.Default - private boolean enabled = true; - @Builder.Default - private Aggregation aggregation = Aggregation.MAX_SIM; - @SerializedName("muvera") - private MuveraConfig muvera; - - public enum Aggregation { - MAX_SIM; - } - - - public MuveraConfig getMuveraEncoding() { - return this.muvera; - } - - // Hide the default getter - private MuveraConfig getMuvera() { - return this.muvera; - } - - public static class MultiVectorConfigBuilder { - private MuveraConfig muvera; - - public MultiVectorConfigBuilder encoding(MuveraConfig muvera) { - this.muvera = muvera; - return this; - } - - // Hide default builder setter - private MultiVectorConfigBuilder muvera(MuveraConfig _muvera) { - return this; - } - - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java deleted file mode 100644 index 5ba3301bf..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/MuveraConfig.java +++ /dev/null @@ -1,21 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class MuveraConfig { - Boolean enabled; - Integer ksim; - Integer dprojections; - Integer repetitions; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/OpenIDConfiguration.java b/src/main/java/io/weaviate/client/v1/misc/model/OpenIDConfiguration.java deleted file mode 100644 index 4984c6b50..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/OpenIDConfiguration.java +++ /dev/null @@ -1,16 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(level = AccessLevel.PRIVATE) -public class OpenIDConfiguration { - String href; - String clientID; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/PQConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/PQConfig.java deleted file mode 100644 index 4a8ab0383..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/PQConfig.java +++ /dev/null @@ -1,36 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class PQConfig { - Boolean enabled; - // HNSW index specific settings - Boolean bitCompression; - Integer segments; - Integer centroids; - Integer trainingLimit; - Encoder encoder; - // Flat index specific settings - Long rescoreLimit; - Boolean cache; - - - @Getter - @Builder - @ToString - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class Encoder { - String type; - String distribution; - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/RQConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/RQConfig.java deleted file mode 100644 index 2019a8573..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/RQConfig.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class RQConfig { - Boolean enabled; - Long bits; - Long rescoreLimit; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/ReplicationConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/ReplicationConfig.java deleted file mode 100644 index 8e645ea19..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/ReplicationConfig.java +++ /dev/null @@ -1,27 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import com.google.gson.annotations.SerializedName; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ReplicationConfig { - Boolean asyncEnabled; - Integer factor; - DeletionStrategy deletionStrategy; - - public enum DeletionStrategy { - @SerializedName("DeleteOnConflict") - DELETE_ON_CONFLICT, - @SerializedName("NoAutomatedResolution") - NO_AUTOMATED_RESOLUTION; - } -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/SQConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/SQConfig.java deleted file mode 100644 index 682b70578..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/SQConfig.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class SQConfig { - Boolean enabled; - Long rescoreLimit; - Boolean cache; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/ShardingConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/ShardingConfig.java deleted file mode 100644 index 3242c1041..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/ShardingConfig.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ShardingConfig { - Integer actualCount; - Integer actualVirtualCount; - Integer desiredCount; - Integer desiredVirtualCount; - String function; - String key; - String strategy; - Integer virtualPerPhysical; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/StopwordConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/StopwordConfig.java deleted file mode 100644 index 3aee31179..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/StopwordConfig.java +++ /dev/null @@ -1,19 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Builder -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class StopwordConfig { - String preset; - String[] additions; - String[] removals; -} diff --git a/src/main/java/io/weaviate/client/v1/misc/model/VectorIndexConfig.java b/src/main/java/io/weaviate/client/v1/misc/model/VectorIndexConfig.java deleted file mode 100644 index c7ed61804..000000000 --- a/src/main/java/io/weaviate/client/v1/misc/model/VectorIndexConfig.java +++ /dev/null @@ -1,43 +0,0 @@ -package io.weaviate.client.v1.misc.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class VectorIndexConfig { - String distance; - Integer ef; - Integer efConstruction; - Integer maxConnections; - Integer dynamicEfMin; - Integer dynamicEfMax; - Integer dynamicEfFactor; - FilterStrategy filterStrategy; - Long vectorCacheMaxObjects; - Integer flatSearchCutoff; - Integer cleanupIntervalSeconds; - Boolean skip; - PQConfig pq; - BQConfig bq; - SQConfig sq; - RQConfig rq; - - @SerializedName("multivector") - MultiVectorConfig multiVector; - - public enum FilterStrategy { - @SerializedName("sweeping") - SWEEPING, @SerializedName("acorn") - ACORN; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/Roles.java b/src/main/java/io/weaviate/client/v1/rbac/Roles.java deleted file mode 100644 index ad903ccd0..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/Roles.java +++ /dev/null @@ -1,101 +0,0 @@ -package io.weaviate.client.v1.rbac; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.api.AssignedUsersGetter; -import io.weaviate.client.v1.rbac.api.GroupAssignmentsGetter; -import io.weaviate.client.v1.rbac.api.PermissionAdder; -import io.weaviate.client.v1.rbac.api.PermissionChecker; -import io.weaviate.client.v1.rbac.api.PermissionRemover; -import io.weaviate.client.v1.rbac.api.RoleAllGetter; -import io.weaviate.client.v1.rbac.api.RoleCreator; -import io.weaviate.client.v1.rbac.api.RoleDeleter; -import io.weaviate.client.v1.rbac.api.RoleExists; -import io.weaviate.client.v1.rbac.api.RoleGetter; -import io.weaviate.client.v1.rbac.api.UserAssignmentsGetter; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Roles { - - private final HttpClient httpClient; - private final Config config; - - /** Create a new role. */ - public RoleCreator creator() { - return new RoleCreator(httpClient, config); - } - - /** Delete a role. */ - public RoleDeleter deleter() { - return new RoleDeleter(httpClient, config); - } - - /** - * Add permissions to an existing role. - * Note: This method is an upsert operation. If the permission already exists, - * it will be updated. If it does not exist, it will be created. - */ - public PermissionAdder permissionAdder() { - return new PermissionAdder(httpClient, config); - } - - /** - * Remove permissions from a role. - * Note: This method is a downsert operation. If the permission does not - * exist, it will be ignored. If these permissions are the only permissions of - * the role, the role will be deleted. - */ - public PermissionRemover permissionRemover() { - return new PermissionRemover(httpClient, config); - } - - /** Check if a role has a permission. */ - public PermissionChecker permissionChecker() { - return new PermissionChecker(httpClient, config); - } - - /** Get all existing roles. */ - public RoleAllGetter allGetter() { - return new RoleAllGetter(httpClient, config); - } - - /** Get role and its associated permissions. */ - public RoleGetter getter() { - return new RoleGetter(httpClient, config); - } - - /** - * Get users assigned to a role. - *

- * Deprecated - prefer {@link #userAssignmentsGetter()} - */ - @Deprecated - public AssignedUsersGetter assignedUsersGetter() { - return new AssignedUsersGetter(httpClient, config); - } - - /** - * Get role assignments. - * - *

- * Note, that the result is not a list of unique users, - * but rather a list of all username+namespace combinations - * allowed for this role. - * In clusters with enabled OIDC authorization, users created dynamically - * (db_user) or configured in the environment (db_env_user) will appear twice: - * once as 'db_*' user and once as 'oidc' user. - */ - public UserAssignmentsGetter userAssignmentsGetter() { - return new UserAssignmentsGetter(httpClient, config); - } - - public GroupAssignmentsGetter groupAssignmentsGetter() { - return new GroupAssignmentsGetter(httpClient, config); - } - - /** Check if a role exists. */ - public RoleExists exists() { - return new RoleExists(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/AssignedUsersGetter.java b/src/main/java/io/weaviate/client/v1/rbac/api/AssignedUsersGetter.java deleted file mode 100644 index 263d170c4..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/AssignedUsersGetter.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class AssignedUsersGetter extends BaseClient implements ClientResult> { - private String role; - - public AssignedUsersGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public AssignedUsersGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Result> run() { - Response resp = sendGetRequest(path(), String[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(new ArrayList<>()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - - private String path() { - return String.format("/authz/roles/%s/users", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/GroupAssignmentsGetter.java b/src/main/java/io/weaviate/client/v1/rbac/api/GroupAssignmentsGetter.java deleted file mode 100644 index 466db8139..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/GroupAssignmentsGetter.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.GroupAssignment; - -public class GroupAssignmentsGetter extends BaseClient - implements ClientResult> { - private String role; - - public GroupAssignmentsGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public GroupAssignmentsGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Result> run() { - return Result.toList(sendGetRequest(path(), GroupAssignment[].class)); - } - - private String path() { - return String.format("/authz/roles/%s/group-assignments", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionAdder.java b/src/main/java/io/weaviate/client/v1/rbac/api/PermissionAdder.java deleted file mode 100644 index 289687714..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionAdder.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Permission; -import lombok.AllArgsConstructor; - -public class PermissionAdder extends BaseClient implements ClientResult { - private String role; - private List> permissions = new ArrayList<>(); - - public PermissionAdder(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public PermissionAdder withRole(String name) { - this.role = name; - return this; - } - - public PermissionAdder withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - @AllArgsConstructor - private static class Body { - public final List permissions; - } - - @Override - public Result run() { - List permissions = WeaviatePermission.mergePermissions(this.permissions); - return Result.voidToBoolean(sendPostRequest(path(), new Body(permissions), Void.class)); - } - - private String path() { - return String.format("/authz/roles/%s/add-permissions", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionChecker.java b/src/main/java/io/weaviate/client/v1/rbac/api/PermissionChecker.java deleted file mode 100644 index 8c6b05190..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionChecker.java +++ /dev/null @@ -1,36 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Permission; - -public class PermissionChecker extends BaseClient implements ClientResult { - private String role; - private Permission permission; - - public PermissionChecker(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public PermissionChecker withRole(String role) { - this.role = role; - return this; - } - - public PermissionChecker withPermission(Permission permission) { - this.permission = permission; - return this; - } - - @Override - public Result run() { - return new Result(sendPostRequest(path(), permission.firstToWeaviate(), Boolean.class)); - } - - private String path() { - return String.format("/authz/roles/%s/has-permission", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionRemover.java b/src/main/java/io/weaviate/client/v1/rbac/api/PermissionRemover.java deleted file mode 100644 index 0f04a9d12..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/PermissionRemover.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Permission; -import lombok.AllArgsConstructor; - -public class PermissionRemover extends BaseClient implements ClientResult { - private String role; - private List> permissions = new ArrayList<>(); - - public PermissionRemover(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public PermissionRemover withRole(String role) { - this.role = role; - return this; - } - - public PermissionRemover withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - @AllArgsConstructor - private static class Body { - public final List permissions; - } - - @Override - public Result run() { - List permissions = WeaviatePermission.mergePermissions(this.permissions); - return Result.voidToBoolean(sendPostRequest(path(), new Body(permissions), Void.class)); - } - - private String path() { - return String.format("/authz/roles/%s/remove-permissions", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/RoleAllGetter.java b/src/main/java/io/weaviate/client/v1/rbac/api/RoleAllGetter.java deleted file mode 100644 index 4519745d1..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/RoleAllGetter.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleAllGetter extends BaseClient implements ClientResult> { - - public RoleAllGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result> run() { - Response resp = sendGetRequest("/authz/roles", WeaviateRole[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(new ArrayList<>()) - .stream() - .map(w -> w.toRole()) - .collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/RoleCreator.java b/src/main/java/io/weaviate/client/v1/rbac/api/RoleCreator.java deleted file mode 100644 index 95c7d7e1c..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/RoleCreator.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Permission; - -public class RoleCreator extends BaseClient implements ClientResult { - private String name; - private List> permissions = new ArrayList<>(); - - public RoleCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public RoleCreator withName(String name) { - this.name = name; - return this; - } - - public RoleCreator withPermissions(Permission... permissions) { - this.permissions = Arrays.asList(permissions); - return this; - } - - @Override - public Result run() { - WeaviateRole role = new WeaviateRole(this.name, this.permissions); - return Result.voidToBoolean(sendPostRequest("/authz/roles", role, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/RoleDeleter.java b/src/main/java/io/weaviate/client/v1/rbac/api/RoleDeleter.java deleted file mode 100644 index 579614b35..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/RoleDeleter.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class RoleDeleter extends BaseClient implements ClientResult { - private String name; - - public RoleDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public RoleDeleter withName(String name) { - this.name = name; - return this; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendDeleteRequest("/authz/roles/" + this.name, null, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/RoleExists.java b/src/main/java/io/weaviate/client/v1/rbac/api/RoleExists.java deleted file mode 100644 index 6b1d5731d..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/RoleExists.java +++ /dev/null @@ -1,38 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleExists extends BaseClient implements ClientResult { - private RoleGetter getter; - - public RoleExists(HttpClient httpClient, Config config) { - super(httpClient, config); - this.getter = new RoleGetter(httpClient, config); - } - - public RoleExists withName(String name) { - this.getter.withName(name); - return this; - } - - @Override - public Result run() { - Result resp = this.getter.run(); - if (resp.hasErrors()) { - WeaviateError error = resp.getError(); - return new Result<>(error.getStatusCode(), null, - WeaviateErrorResponse.builder().error(error.getMessages()).build()); - - } - return new Result(HttpStatus.SC_OK, resp.getResult() != null, null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/RoleGetter.java b/src/main/java/io/weaviate/client/v1/rbac/api/RoleGetter.java deleted file mode 100644 index c07672311..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/RoleGetter.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.Optional; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.Role; - -public class RoleGetter extends BaseClient implements ClientResult { - private String name; - - public RoleGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public RoleGetter withName(String name) { - this.name = name; - return this; - } - - @Override - public Result run() { - Response resp = sendGetRequest("/authz/roles/" + this.name, WeaviateRole.class); - Role role = Optional.ofNullable(resp.getBody()).map(WeaviateRole::toRole).orElse(null); - return new Result(resp.getStatusCode(), role, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/UserAssignmentsGetter.java b/src/main/java/io/weaviate/client/v1/rbac/api/UserAssignmentsGetter.java deleted file mode 100644 index 4ae820f1a..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/UserAssignmentsGetter.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.model.UserAssignment; - -public class UserAssignmentsGetter extends BaseClient implements ClientResult> { - private String role; - - public UserAssignmentsGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public UserAssignmentsGetter withRole(String role) { - this.role = role; - return this; - } - - @Override - public Result> run() { - Response resp = sendGetRequest(path(), UserAssignment[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList).orElse(new ArrayList<>()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - - private String path() { - return String.format("/authz/roles/%s/user-assignments", this.role); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/WeaviatePermission.java b/src/main/java/io/weaviate/client/v1/rbac/api/WeaviatePermission.java deleted file mode 100644 index 34398dc04..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/WeaviatePermission.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.List; - -import io.weaviate.client.v1.rbac.model.AliasPermission; -import io.weaviate.client.v1.rbac.model.BackupsPermission; -import io.weaviate.client.v1.rbac.model.CollectionsPermission; -import io.weaviate.client.v1.rbac.model.DataPermission; -import io.weaviate.client.v1.rbac.model.GroupsPermission; -import io.weaviate.client.v1.rbac.model.NodesPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.ReplicatePermission; -import io.weaviate.client.v1.rbac.model.RolesPermission; -import io.weaviate.client.v1.rbac.model.TenantsPermission; -import io.weaviate.client.v1.rbac.model.UsersPermission; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - -/** API model for serializing/deserializing permissions. */ -@Getter -@Builder -@AllArgsConstructor -@EqualsAndHashCode -@ToString -public class WeaviatePermission { - String action; - AliasPermission aliases; - BackupsPermission backups; - CollectionsPermission collections; - DataPermission data; - GroupsPermission groups; - NodesPermission nodes; - RolesPermission roles; - TenantsPermission tenants; - UsersPermission users; - ReplicatePermission replicate; - - public WeaviatePermission(String action) { - this.action = action; - } - - public

> WeaviatePermission(String action, Permission

perm) { - this.action = action; - if (perm instanceof AliasPermission) { - this.aliases = (AliasPermission) perm; - } else if (perm instanceof BackupsPermission) { - this.backups = (BackupsPermission) perm; - } else if (perm instanceof CollectionsPermission) { - this.collections = (CollectionsPermission) perm; - } else if (perm instanceof DataPermission) { - this.data = (DataPermission) perm; - } else if (perm instanceof GroupsPermission) { - this.groups = (GroupsPermission) perm; - } else if (perm instanceof NodesPermission) { - this.nodes = (NodesPermission) perm; - } else if (perm instanceof RolesPermission) { - this.roles = (RolesPermission) perm; - } else if (perm instanceof TenantsPermission) { - this.tenants = (TenantsPermission) perm; - } else if (perm instanceof UsersPermission) { - this.users = (UsersPermission) perm; - } else if (perm instanceof ReplicatePermission) { - this.replicate = (ReplicatePermission) perm; - } - } - - public static List mergePermissions(List> permissions) { - List merged = new ArrayList<>(); - for (Permission perm : permissions) { - merged.addAll(perm.toWeaviate()); - } - return merged; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/api/WeaviateRole.java b/src/main/java/io/weaviate/client/v1/rbac/api/WeaviateRole.java deleted file mode 100644 index b542197d9..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/api/WeaviateRole.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.Optional; -import java.util.stream.Collectors; - -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.Role; -import lombok.Getter; - -/** API model for serializing/deserializing roles. */ -@Getter -public class WeaviateRole { - String name; - List permissions; - - public WeaviateRole(String name, List> permissions) { - this.name = name; - this.permissions = WeaviatePermission.mergePermissions(permissions); - } - - /** Exposed for testing. */ - WeaviateRole(String name, WeaviatePermission... permissions) { - this.name = name; - this.permissions = Arrays.asList(permissions); - } - - /** Create {@link Role} from the API response object. */ - public Role toRole() { - List> permissions = Optional.ofNullable(this.permissions) - .orElse(new ArrayList<>()).stream() - .>map(perm -> Permission.fromWeaviate(perm)) - .filter(Objects::nonNull).collect(Collectors.toList()); - return new Role(this.name, Permission.merge(permissions)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/AliasPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/AliasPermission.java deleted file mode 100644 index bfae4020a..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/AliasPermission.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class AliasPermission extends Permission { - final String alias; - final String collection; - - public AliasPermission(String alias, String collection, Action... actions) { - super(actions); - this.alias = alias; - this.collection = collection; - } - - AliasPermission(String alias, String collection, String action) { - this(alias, collection, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_aliases"), - READ("read_aliases"), - UPDATE("update_aliases"), - DELETE("delete_aliases"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/BackupsPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/BackupsPermission.java deleted file mode 100644 index 72016f22f..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/BackupsPermission.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class BackupsPermission extends Permission { - final String collection; - - public BackupsPermission(String collection, Action... actions) { - super(actions); - this.collection = collection; - } - - BackupsPermission(String collection, String action) { - this(collection, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - MANAGE("manage_backups"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/ClusterPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/ClusterPermission.java deleted file mode 100644 index 312fb4b8d..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/ClusterPermission.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class ClusterPermission extends Permission { - public ClusterPermission(Action... actions) { - super(actions); - } - - ClusterPermission(String action) { - this(RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - READ("read_cluster"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/CollectionsPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/CollectionsPermission.java deleted file mode 100644 index e418bfba9..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/CollectionsPermission.java +++ /dev/null @@ -1,34 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class CollectionsPermission extends Permission { - final String collection; - - public CollectionsPermission(String collection, Action... actions) { - super(actions); - this.collection = collection; - } - - CollectionsPermission(String collection, String action) { - this(collection, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_collections"), - READ("read_collections"), - UPDATE("update_collections"), - DELETE("delete_collections"); - - // Not part of the public API yet. - // MANAGE("manage_collections"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/DataPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/DataPermission.java deleted file mode 100644 index 8b952b6b6..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/DataPermission.java +++ /dev/null @@ -1,32 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class DataPermission extends Permission { - final String collection; - - public DataPermission(String collection, Action... actions) { - super(actions); - this.collection = collection; - } - - DataPermission(String collection, String action) { - this(collection, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_data"), - READ("read_data"), - UPDATE("update_data"), - DELETE("delete_data"), - MANAGE("manage_data"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/GroupAssignment.java b/src/main/java/io/weaviate/client/v1/rbac/model/GroupAssignment.java deleted file mode 100644 index 4036f8e03..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/GroupAssignment.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - -@Getter -@ToString -@AllArgsConstructor -public class GroupAssignment { - @SerializedName("groupId") - String groupId; - - @SerializedName("groupType") - String groupType; -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/GroupsPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/GroupsPermission.java deleted file mode 100644 index 64f19d9b0..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/GroupsPermission.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class GroupsPermission extends Permission { - final String groupId; - final String groupType; - - public GroupsPermission(String groupId, String groupType, Action... actions) { - super(actions); - this.groupId = groupId; - this.groupType = groupType; - } - - GroupsPermission(String groupId, String groupType, String action) { - this(groupId, groupType, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - READ("read_groups"), - ASSIGN_AND_REVOKE("assign_and_revoke_groups"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/NodesPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/NodesPermission.java deleted file mode 100644 index e0da98ca1..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/NodesPermission.java +++ /dev/null @@ -1,57 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class NodesPermission extends Permission { - final String collection; - final Verbosity verbosity; - - /** Create permission scoped to all collections. */ - public NodesPermission(Verbosity verbosity, Action... actions) { - this("*", verbosity, actions); - } - - /** - * Permission scoped to a collection with {@link Verbosity#VERBOSE}. - */ - public NodesPermission(String collection, Action... actions) { - this(collection, Verbosity.VERBOSE, actions); - } - - NodesPermission(Verbosity verbosity, String action) { - this(verbosity, RbacAction.fromString(Action.class, action)); - } - - NodesPermission(String collection, Verbosity verbosity, String action) { - this(collection, verbosity, RbacAction.fromString(Action.class, action)); - } - - NodesPermission(String collection, Verbosity verbosity, Action... actions) { - super(actions); - this.collection = collection; - this.verbosity = verbosity; - } - - @AllArgsConstructor - public enum Action implements RbacAction { - READ("read_nodes"); - - @Getter - private final String value; - } - - @AllArgsConstructor - public enum Verbosity { - @SerializedName("minimal") - MINIMAL, - @SerializedName("verbose") - VERBOSE; - } - -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/Permission.java b/src/main/java/io/weaviate/client/v1/rbac/model/Permission.java deleted file mode 100644 index e3c0bff8e..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/Permission.java +++ /dev/null @@ -1,282 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import java.util.Arrays; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; - -import org.apache.commons.lang3.builder.HashCodeBuilder; - -import io.weaviate.client.v1.async.rbac.api.PermissionChecker; -import io.weaviate.client.v1.rbac.api.WeaviatePermission; -import io.weaviate.client.v1.rbac.model.NodesPermission.Verbosity; -import lombok.EqualsAndHashCode; -import lombok.ToString; - -@EqualsAndHashCode -@ToString -public abstract class Permission

> { - /** - * Actions allowed by this permission. Transience allows easily - * serializing "action" separately from other attributes in the - * extending permission types. - * - * LinkedHashSet preserves insertion order for predictability. - */ - final transient Set actions = new LinkedHashSet<>(); - - public List getActions() { - return actions.stream().collect(Collectors.toList()); - } - - Permission(RbacAction... actions) { - this.actions.addAll( - Arrays.stream(actions) - .map(RbacAction::getValue) - .collect(Collectors.toList())); - } - - /** - * Create {@link WeaviatePermission} with the first action in the actions list. - * - * This is meant to be used with {@link PermissionChecker}, which can only - * include a permission with a single action in the request. - */ - public WeaviatePermission firstToWeaviate() { - if (actions.isEmpty()) { - return null; - } - return this.toWeaviate(actions.iterator().next()); - }; - - /** Convert the permission to a list of {@link WeaviatePermission}. */ - public List toWeaviate() { - return this.actions.stream().map(this::toWeaviate).collect(Collectors.toList()); - } - - private WeaviatePermission toWeaviate(String action) { - return new WeaviatePermission(action, this); - } - - /** - * Convert {@link WeaviatePermission} to concrete {@link Permission}. - */ - public static Permission fromWeaviate(WeaviatePermission perm) { - String action = perm.getAction(); - if (perm.getAliases() != null) { - AliasPermission aliases = perm.getAliases(); - return new AliasPermission(aliases.getAlias(), aliases.getCollection(), action); - } else if (perm.getBackups() != null) { - return new BackupsPermission(perm.getBackups().getCollection(), action); - } else if (perm.getCollections() != null) { - return new CollectionsPermission(perm.getCollections().getCollection(), action); - } else if (perm.getData() != null) { - return new DataPermission(perm.getData().getCollection(), action); - } else if (perm.getGroups() != null) { - GroupsPermission groups = perm.getGroups(); - return new GroupsPermission(groups.getGroupId(), groups.getGroupType(), action); - } else if (perm.getNodes() != null) { - NodesPermission nodes = perm.getNodes(); - if (nodes.getCollection() != null) { - return new NodesPermission(nodes.getCollection(), nodes.getVerbosity(), action); - } - return new NodesPermission(nodes.getVerbosity(), action); - } else if (perm.getRoles() != null) { - RolesPermission roles = perm.getRoles(); - return new RolesPermission(roles.getRole(), roles.getScope(), action); - } else if (perm.getTenants() != null) { - return new TenantsPermission(action); - } else if (perm.getReplicate() != null) { - ReplicatePermission replicate = perm.getReplicate(); - return new ReplicatePermission(replicate.getCollection(), replicate.getShard(), action); - - // Cluster-/UserPermission do not have any additional data, so we can only - // identify them based on the action. - } else if (RbacAction.isValid(ClusterPermission.Action.class, action)) { - return new ClusterPermission(action); - } else if (RbacAction.isValid(UsersPermission.Action.class, action)) { - return new UsersPermission(action); - } - return null; - } - - /** - * Merge permissions by their type and targeted resource. Weaviate server - * returns separate entries for each action, but working with a - * permission-per-resource model is more convenient. - * - *

- * Example: convert Data[read_data, MyCollection], Data[delete_data, - * MyCollection] to Data[[read_data, delete_data], MyCollection]. - */ - public static final List> merge(List> permissions) { - @EqualsAndHashCode - class Key { - // hash is computed on all permission fields apart from "actions" which - // is what we need to aggregate. - final int hash; - // Permission types which do not have any filters differentiate by their class. - final Class cls; - - private Key(Object object) { - this.hash = HashCodeBuilder.reflectionHashCode(object, "actions"); - this.cls = object.getClass(); - } - } - - Map> result = new LinkedHashMap<>(); // preserve insertion order - for (Permission perm : permissions) { - Key key = new Key(perm); - Permission stored = result.putIfAbsent(key, perm); - if (stored != null) { // A permission for this key already exists, add all actions. - stored.actions.addAll(perm.actions); - } - } - return result.values().stream().collect(Collectors.toList()); - } - - /** - * Create {@link AliasPermission} for an alias. - *

- * Example: - * {@code Permission.alias("PizzaAlias", "Pizza", AliasPermission.Action.CREATE) } - */ - public static AliasPermission alias(String alias, String collection, AliasPermission.Action... actions) { - checkDeprecation(actions); - return new AliasPermission(alias, collection, actions); - } - - /** - * Create {@link BackupsPermission} for a collection. - *

- * Example: - * {@code Permission.backups("Pizza", BackupsPermission.Action.MANAGE) } - */ - public static BackupsPermission backups(String collection, BackupsPermission.Action... actions) { - checkDeprecation(actions); - return new BackupsPermission(collection, actions); - } - - /** - * Create {@link ClusterPermission} permission. - *

- * Example: {@code Permission.cluster(ClusterPermission.Action.READ) } - */ - public static ClusterPermission cluster(ClusterPermission.Action... actions) { - checkDeprecation(actions); - return new ClusterPermission(actions); - } - - /** - * Create permission for collection's configuration. - *

- * Example: - * {@code Permission.collections("Pizza", CollectionsPermission.Action.READ, CollectionsPermission.Action.UPDATE) } - */ - public static CollectionsPermission collections(String collection, CollectionsPermission.Action... actions) { - checkDeprecation(actions); - return new CollectionsPermission(collection, actions); - } - - /** - * Create permissions for multiple actions for managing collection's data. - *

- * Example: - * {@code Permission.data("Pizza", DataPermission.Action.READ, DataPermission.Action.UPDATE) } - */ - public static DataPermission data(String collection, DataPermission.Action... actions) { - checkDeprecation(actions); - return new DataPermission(collection, actions); - } - - /** - * Create permissions for multiple actions for managing RBAC groups. - *

- * Example: - * {@code Permission.groups("admin-group", "oidc", GroupsPermission.Action.READ, GroupsPermission.Action.ASSIGN_AND_REVOKE) } - */ - public static GroupsPermission groups(String groupId, String groupType, GroupsPermission.Action... actions) { - checkDeprecation(actions); - return new GroupsPermission(groupId, groupType, actions); - } - - /** - * Create {@link NodesPermission} scoped to all collections. - *

- * Example: - * {@code Permission.nodes(NodesPermission.Verbosity.MINIMAL, NodesPermission.Action.READ) } - */ - public static NodesPermission nodes(NodesPermission.Verbosity verbosity, NodesPermission.Action... actions) { - checkDeprecation(actions); - return new NodesPermission(verbosity, actions); - } - - /** - * Create {@link NodesPermission} scoped to a specific collection. Verbosity is - * set to {@link Verbosity#VERBOSE} by default. - *

- * Example: - * {@code Permission.nodes("Pizza", NodesPermission.Action.READ) } - */ - public static NodesPermission nodes(String collection, NodesPermission.Action... actions) { - checkDeprecation(actions); - return new NodesPermission(collection, actions); - } - - /** - * Create {@link RolesPermission} for multiple actions. - *

- * Example: - * {@code Permission.roles("MyRole", RolesPermission.Action.READ, RolesPermission.Action.UPDATE) } - */ - public static RolesPermission roles(String role, RolesPermission.Action... actions) { - checkDeprecation(actions); - return new RolesPermission(role, actions); - } - - /** - * Create {@link TenantsPermission} for a tenant. - *

- * Example: - * {@code Permission.tenants(TenantsPermission.Action.READ) } - */ - public static TenantsPermission tenants(TenantsPermission.Action... actions) { - checkDeprecation(actions); - return new TenantsPermission(actions); - } - - /** - * Create {@link UsersPermission}. - *

- * Example: - * {@code Permission.users(UsersPermission.Action.READ) } - */ - public static UsersPermission users(UsersPermission.Action... actions) { - checkDeprecation(actions); - return new UsersPermission(actions); - } - - /** - * Create {@link ReplicatePermission}. - * - *

- * Example: - * {@code Permissions.replicate("Pizza", "shard-123", ReplicatePermission.Action.CREATE)} - */ - public static ReplicatePermission replicate(String collection, String shard, ReplicatePermission.Action... actions) { - checkDeprecation(actions); - return new ReplicatePermission(collection, shard, actions); - } - - private static void checkDeprecation(RbacAction... actions) throws IllegalArgumentException { - for (RbacAction action : actions) { - if (action.isDeprecated()) { - throw new IllegalArgumentException(action.getValue() - + " is hard-deprecated and should only be used to read legacy permissions created in v1.28"); - } - } - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/RbacAction.java b/src/main/java/io/weaviate/client/v1/rbac/model/RbacAction.java deleted file mode 100644 index 60d495209..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/RbacAction.java +++ /dev/null @@ -1,62 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -/** - * RbacAction is a utility interface to allow retrieving concrete enum values - * from their underlying string representations. - * - *

- * Usage: - * - *

{@code
- * enum MyAction implements RbacAction {
- *   FOO("do_foo"),
- *   BAR("do_bar");
- *
- *   {@literal @Getter}
- *   private String value;
- * }
- * }
- * - *

- * Then {@code MyAction.FOO} can be retrieved from "do_foo" using - * {@link #fromString}. - */ -interface RbacAction { - String getValue(); - - /** - * Returns true if the action is hard deprecated. - * - *

- * Override default return for a deprecated enum value like so: - * - *

{@code
-   * OLD_ACTION("old_action") {
-   *  {@literal @Override}
-   *  public boolean isDeprecated() { return true; }
-   * };
-   * }
- */ - default boolean isDeprecated() { - return false; - } - - static & RbacAction> E fromString(Class enumClass, String value) - throws IllegalArgumentException { - for (E action : enumClass.getEnumConstants()) { - if (action.getValue().equals(value)) { - return action; - } - } - throw new IllegalArgumentException("No enum constant for value: " + value); - } - - static boolean isValid(Class enumClass, String value) { - for (RbacAction action : enumClass.getEnumConstants()) { - if (action.getValue().equals(value)) { - return true; - } - } - return false; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/ReplicatePermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/ReplicatePermission.java deleted file mode 100644 index 7395d3c30..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/ReplicatePermission.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class ReplicatePermission extends Permission { - final String collection; - final String shard; - - public final String getShard() { - return shard != null ? shard : "*"; - } - - public ReplicatePermission(String collection, String shard, Action... actions) { - super(actions); - this.collection = collection; - this.shard = shard; - } - - ReplicatePermission(String collection, String shard, String action) { - this(collection, shard, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_replicate"), - READ("read_replicate"), - UPDATE("update_replicate"), - DELETE("delete_replicate"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/Role.java b/src/main/java/io/weaviate/client/v1/rbac/model/Role.java deleted file mode 100644 index 52c9c8bec..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/Role.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Collectors; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@AllArgsConstructor -@EqualsAndHashCode -public class Role { - public final String name; - public List> permissions = new ArrayList<>(); - - public String toString() { - return String.format( - "Role", - this.name, permissions.isEmpty() - ? "none" - : String.join(",\n", permissions.stream().map(Permission::toString) - .collect(Collectors.toList()))); - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/RolesPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/RolesPermission.java deleted file mode 100644 index dd2e3fbb0..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/RolesPermission.java +++ /dev/null @@ -1,59 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class RolesPermission extends Permission { - final String role; - final Scope scope; - - public RolesPermission(String role, Action... actions) { - this(role, null, actions); - } - - public RolesPermission(String role, Scope scope, Action... actions) { - super(actions); - this.role = role; - this.scope = scope; - } - - RolesPermission(String role, Scope scope, String action) { - this(role, scope, RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_roles"), - READ("read_roles"), - UPDATE("update_roles"), - DELETE("delete_roles"), - - /* - * DO NOT CREATE NEW PERMISSIONS WITH THIS ACTION. - * It is preserved for backward compatibility with 1.28 - * and should only be used internally to read legacy permissions. - */ - @Deprecated - MANAGE("manage_roles") { - @Override - public boolean isDeprecated() { - return true; - }; - }; - - @Getter - private final String value; - } - - public enum Scope { - @SerializedName("all") - ALL, - @SerializedName("match") - MATCH; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/TenantsPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/TenantsPermission.java deleted file mode 100644 index 2229b36d3..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/TenantsPermission.java +++ /dev/null @@ -1,29 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode(callSuper = true) -public class TenantsPermission extends Permission { - - public TenantsPermission(Action... actions) { - super(actions); - } - - TenantsPermission(String action) { - this(RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_tenants"), - READ("read_tenants"), - UPDATE("update_tenants"), - DELETE("delete_tenants"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/UserAssignment.java b/src/main/java/io/weaviate/client/v1/rbac/model/UserAssignment.java deleted file mode 100644 index b02db1166..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/UserAssignment.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import com.google.gson.annotations.SerializedName; - -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - -@Getter -@ToString -@AllArgsConstructor -public class UserAssignment { - @SerializedName("userId") - String userId; - - @SerializedName("userType") - String userType; -} diff --git a/src/main/java/io/weaviate/client/v1/rbac/model/UsersPermission.java b/src/main/java/io/weaviate/client/v1/rbac/model/UsersPermission.java deleted file mode 100644 index b74ac7e7c..000000000 --- a/src/main/java/io/weaviate/client/v1/rbac/model/UsersPermission.java +++ /dev/null @@ -1,27 +0,0 @@ - -package io.weaviate.client.v1.rbac.model; - -import lombok.AllArgsConstructor; -import lombok.Getter; - -public class UsersPermission extends Permission { - public UsersPermission(Action... actions) { - super(actions); - } - - UsersPermission(String action) { - this(RbacAction.fromString(Action.class, action)); - } - - @AllArgsConstructor - public enum Action implements RbacAction { - CREATE("create_users"), - UPDATE("update_users"), - READ("read_users"), - DELETE("delete_users"), - ASSIGN_AND_REVOKE("assign_and_revoke_users"); - - @Getter - private final String value; - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/Schema.java b/src/main/java/io/weaviate/client/v1/schema/Schema.java deleted file mode 100644 index 8dde3d5ba..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/Schema.java +++ /dev/null @@ -1,102 +0,0 @@ -package io.weaviate.client.v1.schema; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.schema.api.ClassCreator; -import io.weaviate.client.v1.schema.api.ClassDeleter; -import io.weaviate.client.v1.schema.api.ClassExists; -import io.weaviate.client.v1.schema.api.ClassGetter; -import io.weaviate.client.v1.schema.api.ClassUpdater; -import io.weaviate.client.v1.schema.api.PropertyCreator; -import io.weaviate.client.v1.schema.api.SchemaDeleter; -import io.weaviate.client.v1.schema.api.SchemaGetter; -import io.weaviate.client.v1.schema.api.ShardUpdater; -import io.weaviate.client.v1.schema.api.ShardsGetter; -import io.weaviate.client.v1.schema.api.ShardsUpdater; -import io.weaviate.client.v1.schema.api.TenantsCreator; -import io.weaviate.client.v1.schema.api.TenantsDeleter; -import io.weaviate.client.v1.schema.api.TenantsExists; -import io.weaviate.client.v1.schema.api.TenantsGetter; -import io.weaviate.client.v1.schema.api.TenantsUpdater; -import io.weaviate.client.v1.schema.api.VectorAdder; - -public class Schema { - private final Config config; - private final HttpClient httpClient; - private final DbVersionSupport dbVersionSupport; - - public Schema(HttpClient httpClient, Config config, DbVersionSupport dbVersionSupport) { - this.config = config; - this.httpClient = httpClient; - this.dbVersionSupport = dbVersionSupport; - } - - public SchemaGetter getter() { - return new SchemaGetter(httpClient, config); - } - - public ClassGetter classGetter() { - return new ClassGetter(httpClient, config); - } - - public ClassExists exists() { - return new ClassExists(new ClassGetter(httpClient, config)); - } - - public ClassCreator classCreator() { - return new ClassCreator(httpClient, config); - } - - public ClassUpdater classUpdater() { - return new ClassUpdater(httpClient, config); - } - - public ClassDeleter classDeleter() { - return new ClassDeleter(httpClient, config); - } - - public PropertyCreator propertyCreator() { - return new PropertyCreator(httpClient, config); - } - - public VectorAdder vectorAdder() { - return new VectorAdder(httpClient, config); - } - - public SchemaDeleter allDeleter() { - return new SchemaDeleter(new SchemaGetter(httpClient, config), new ClassDeleter(httpClient, config)); - } - - public ShardsGetter shardsGetter() { - return new ShardsGetter(httpClient, config); - } - - public ShardUpdater shardUpdater() { - return new ShardUpdater(httpClient, config); - } - - public ShardsUpdater shardsUpdater() { - return new ShardsUpdater(httpClient, config); - } - - public TenantsCreator tenantsCreator() { - return new TenantsCreator(httpClient, config); - } - - public TenantsUpdater tenantsUpdater() { - return new TenantsUpdater(httpClient, config, dbVersionSupport); - } - - public TenantsDeleter tenantsDeleter() { - return new TenantsDeleter(httpClient, config); - } - - public TenantsGetter tenantsGetter() { - return new TenantsGetter(httpClient, config); - } - - public TenantsExists tenantsExists() { - return new TenantsExists(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ClassCreator.java b/src/main/java/io/weaviate/client/v1/schema/api/ClassCreator.java deleted file mode 100644 index 96b51c389..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ClassCreator.java +++ /dev/null @@ -1,29 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class ClassCreator extends BaseClient implements ClientResult { - - private WeaviateClass clazz; - - public ClassCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ClassCreator withClass(WeaviateClass clazz) { - this.clazz = clazz; - return this; - } - - @Override - public Result run() { - Response resp = sendPostRequest("/schema", clazz, WeaviateClass.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ClassDeleter.java b/src/main/java/io/weaviate/client/v1/schema/api/ClassDeleter.java deleted file mode 100644 index 692cc373a..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ClassDeleter.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class ClassDeleter extends BaseClient implements ClientResult { - - private String className; - - public ClassDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ClassDeleter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - String path = String.format("/schema/%s", this.className); - Response resp = sendDeleteRequest(path, null, String.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ClassExists.java b/src/main/java/io/weaviate/client/v1/schema/api/ClassExists.java deleted file mode 100644 index 2cd8f9962..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ClassExists.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.core5.http.HttpStatus; - -import java.util.Collections; - -public class ClassExists implements ClientResult { - private final ClassGetter classGetter; - private String className; - - public ClassExists(ClassGetter classGetter) { - this.classGetter = classGetter; - } - - public ClassExists withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return new Result<>(HttpStatus.SC_UNPROCESSABLE_ENTITY, null, errors); - } - - Result getterClass = classGetter.withClassName(className).run(); - if (getterClass.hasErrors()) { - WeaviateError error = getterClass.getError(); - return new Result<>(error.getStatusCode(), null, WeaviateErrorResponse.builder().error(error.getMessages()).build()); - } - return new Result<>(HttpStatus.SC_OK, getterClass.getResult() != null, null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ClassGetter.java b/src/main/java/io/weaviate/client/v1/schema/api/ClassGetter.java deleted file mode 100644 index 18ee283c6..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ClassGetter.java +++ /dev/null @@ -1,42 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class ClassGetter extends BaseClient implements ClientResult { - - private String className; - - public ClassGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ClassGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, null, errors); - } - String path = String.format("/schema/%s", this.className); - Response resp = sendGetRequest(path, WeaviateClass.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ClassUpdater.java b/src/main/java/io/weaviate/client/v1/schema/api/ClassUpdater.java deleted file mode 100644 index f099be85d..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ClassUpdater.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.WeaviateClass; - -public class ClassUpdater extends BaseClient implements ClientResult { - - private WeaviateClass clazz; - - public ClassUpdater(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ClassUpdater withClass(WeaviateClass clazz) { - this.clazz = clazz; - return this; - } - - @Override - public Result run() { - String path = String.format("/schema/%s", UrlEncoder.encodePathParam(clazz.getClassName())); - Response resp = sendPutRequest(path, clazz, WeaviateClass.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/PropertyCreator.java b/src/main/java/io/weaviate/client/v1/schema/api/PropertyCreator.java deleted file mode 100644 index 625284022..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/PropertyCreator.java +++ /dev/null @@ -1,48 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.Property; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.commons.lang3.StringUtils; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class PropertyCreator extends BaseClient implements ClientResult { - - private String className; - private Property property; - - public PropertyCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public PropertyCreator withClassName(String className) { - this.className = className; - return this; - } - - public PropertyCreator withProperty(Property property) { - this.property = property; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("classname cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Stream.of(errorMessage).collect(Collectors.toList())).build(); - return new Result<>(500, false, errors); - } - String path = String.format("/schema/%s/properties", this.className); - Response resp = sendPostRequest(path, property, Property.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/SchemaDeleter.java b/src/main/java/io/weaviate/client/v1/schema/api/SchemaDeleter.java deleted file mode 100644 index 0c5c48412..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/SchemaDeleter.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.List; -import java.util.stream.Collectors; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; - -public class SchemaDeleter { - private SchemaGetter schemaGetter; - private ClassDeleter classDeleter; - - public SchemaDeleter(SchemaGetter schemaGetter, ClassDeleter classDeleter) { - this.schemaGetter = schemaGetter; - this.classDeleter = classDeleter; - } - - public Result run() { - Result schema = schemaGetter.run(); - if (schema.getError() != null) { - List errorMessages = schema.getError().getMessages().stream().map(err -> - WeaviateErrorMessage.builder().message(err.getMessage()).build() - ).collect(Collectors.toList()); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(errorMessages).build(); - return new Result<>(schema.getError().getStatusCode(), false, errors); - } - if (schema.getError() == null) { - List weaviateClasses = schema.getResult().getClasses(); - for (WeaviateClass clazz : weaviateClasses) { - Result result = classDeleter.withClassName(clazz.getClassName()).run(); - if (result.getError() != null) { - return result; - } - } - } - return new Result<>(200, true, null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/SchemaGetter.java b/src/main/java/io/weaviate/client/v1/schema/api/SchemaGetter.java deleted file mode 100644 index 0dd1f34f0..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/SchemaGetter.java +++ /dev/null @@ -1,22 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class SchemaGetter extends BaseClient implements ClientResult { - - public SchemaGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result run() { - Response resp = sendGetRequest("/schema", Schema.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ShardUpdater.java b/src/main/java/io/weaviate/client/v1/schema/api/ShardUpdater.java deleted file mode 100644 index a27240908..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ShardUpdater.java +++ /dev/null @@ -1,66 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.schema.model.ShardStatus; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.core5.http.HttpStatus; - -public class ShardUpdater extends BaseClient implements ClientResult { - private String className; - private String shardName; - private ShardStatus status; - - public ShardUpdater(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ShardUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ShardUpdater withShardName(String shardName) { - this.shardName = shardName; - return this; - } - - public ShardUpdater withStatus(String targetStatus) { - this.status = ShardStatus.builder().status(targetStatus).build(); - return this; - } - - @Override - public Result run() { - List emptyFieldNames = new ArrayList<>(); - if (StringUtils.isEmpty(this.className)) { - emptyFieldNames.add("className"); - } - if (StringUtils.isEmpty(this.shardName)) { - emptyFieldNames.add("shardName"); - } - if (this.status == null) { - emptyFieldNames.add("status"); - } - if (emptyFieldNames.size() > 0) { - String message = String.format("%s cannot be empty", StringUtils.joinWith(", ", emptyFieldNames.toArray())); - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message(message).build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors); - } - String path = String.format("/schema/%s/shards/%s", this.className, this.shardName); - Response resp = sendPutRequest(path, status, ShardStatus.class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ShardsGetter.java b/src/main/java/io/weaviate/client/v1/schema/api/ShardsGetter.java deleted file mode 100644 index 37282fe5d..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ShardsGetter.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.schema.model.Shard; -import java.util.Collections; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.core5.http.HttpStatus; - -public class ShardsGetter extends BaseClient implements ClientResult { - private String className; - - public ShardsGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ShardsGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Result run() { - if (StringUtils.isEmpty(this.className)) { - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder() - .message("className cannot be empty").build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors); - } - String path = String.format("/schema/%s/shards", this.className); - Response resp = sendGetRequest(path, Shard[].class); - return new Result<>(resp); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/ShardsUpdater.java b/src/main/java/io/weaviate/client/v1/schema/api/ShardsUpdater.java deleted file mode 100644 index c42949884..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/ShardsUpdater.java +++ /dev/null @@ -1,81 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.v1.schema.model.Shard; -import io.weaviate.client.v1.schema.model.ShardStatus; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import org.apache.commons.lang3.StringUtils; -import org.apache.hc.core5.http.HttpStatus; -import io.weaviate.client.Config; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.base.WeaviateErrorResponse; -import io.weaviate.client.base.http.HttpClient; - -public class ShardsUpdater implements ClientResult { - private final ShardsGetter shardsGetter; - private final ShardUpdater shardUpdater; - - private String className; - private String status; - - public ShardsUpdater(HttpClient httpClient, Config config) { - this.shardsGetter = new ShardsGetter(httpClient, config); - this.shardUpdater = new ShardUpdater(httpClient, config); - } - - public ShardsUpdater withClassName(String className) { - this.className = className; - return this; - } - - public ShardsUpdater withStatus(String targetStatus) { - this.status = targetStatus; - return this; - } - - private Result toResult(WeaviateError error) { - return new Result<>(error.getStatusCode(), null, WeaviateErrorResponse.builder().error(error.getMessages()).build()); - } - - @Override - public Result run() { - List emptyFieldNames = new ArrayList<>(); - if (StringUtils.isEmpty(this.className)) { - emptyFieldNames.add("className"); - } - if (this.status == null) { - emptyFieldNames.add("status"); - } - if (emptyFieldNames.size() > 0) { - String message = String.format("%s cannot be empty", StringUtils.joinWith(", ", emptyFieldNames.toArray())); - WeaviateErrorMessage errorMessage = WeaviateErrorMessage.builder().message(message).build(); - WeaviateErrorResponse errors = WeaviateErrorResponse.builder() - .error(Collections.singletonList(errorMessage)).build(); - return new Result<>(HttpStatus.SC_BAD_REQUEST, null, errors); - } - - Result shards = this.shardsGetter.withClassName(this.className).run(); - if (shards.hasErrors()) { - return toResult(shards.getError()); - } - - List shardStatuses = new ArrayList<>(); - for (Shard shard : shards.getResult()) { - Result update = this.shardUpdater - .withClassName(this.className) - .withShardName(shard.getName()) - .withStatus(this.status) - .run(); - if (update.hasErrors()) { - return toResult(update.getError()); - } - shardStatuses.add(update.getResult()); - } - - return new Result<>(HttpStatus.SC_OK, shardStatuses.toArray(new ShardStatus[shardStatuses.size()]), null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/TenantsCreator.java b/src/main/java/io/weaviate/client/v1/schema/api/TenantsCreator.java deleted file mode 100644 index ee77a621f..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/TenantsCreator.java +++ /dev/null @@ -1,43 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.Tenant; - -public class TenantsCreator extends BaseClient implements ClientResult { - - private String className; - private Tenant[] tenants; - - public TenantsCreator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public TenantsCreator withClassName(String className) { - this.className = className; - return this; - } - - public TenantsCreator withTenants(Tenant... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Result run() { - return createTenants(tenants); - } - - private Result createTenants(Tenant[] tenants) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - Response resp = sendPostRequest(path, tenants, Tenant[].class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/TenantsDeleter.java b/src/main/java/io/weaviate/client/v1/schema/api/TenantsDeleter.java deleted file mode 100644 index 32a9fe8fe..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/TenantsDeleter.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsDeleter extends BaseClient implements ClientResult { - - private String className; - private String[] tenants; - - public TenantsDeleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public TenantsDeleter withClassName(String className) { - this.className = className; - return this; - } - - public TenantsDeleter withTenants(String... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Result run() { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - Response resp = sendDeleteRequest(path, tenants, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/TenantsExists.java b/src/main/java/io/weaviate/client/v1/schema/api/TenantsExists.java deleted file mode 100644 index 1a5595c4e..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/TenantsExists.java +++ /dev/null @@ -1,37 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsExists extends BaseClient implements ClientResult { - - private String className; - private String tenant; - - public TenantsExists(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public TenantsExists withClassName(String className) { - this.className = className; - return this; - } - - public TenantsExists withTenant(String tenant) { - this.tenant = tenant; - return this; - } - - @Override - public Result run() { - String path = String.format("/schema/%s/tenants/%s", UrlEncoder.encodePathParam(className), UrlEncoder.encodePathParam(tenant)); - Response resp = sendHeadRequest(path, Object.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/TenantsGetter.java b/src/main/java/io/weaviate/client/v1/schema/api/TenantsGetter.java deleted file mode 100644 index 6a63e1531..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/TenantsGetter.java +++ /dev/null @@ -1,39 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.Tenant; - -import java.util.Arrays; -import java.util.List; -import java.util.Optional; - -public class TenantsGetter extends BaseClient implements ClientResult> { - - private String className; - - public TenantsGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public TenantsGetter withClassName(String className) { - this.className = className; - return this; - } - - @Override - public Result> run() { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - Response resp = sendGetRequest(path, Tenant[].class); - - List tenants = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList) - .orElse(null); - return new Result<>(resp.getStatusCode(), tenants, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/TenantsUpdater.java b/src/main/java/io/weaviate/client/v1/schema/api/TenantsUpdater.java deleted file mode 100644 index 73a534997..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/TenantsUpdater.java +++ /dev/null @@ -1,65 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.Tenant; -import java.util.Collection; -import java.util.List; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.apache.hc.core5.http.HttpStatus; - -public class TenantsUpdater extends BaseClient implements ClientResult { - - private final static int BATCH_SIZE = 100; - private final DbVersionSupport dbVersionSupport; - private String className; - private Tenant[] tenants; - - public TenantsUpdater(HttpClient httpClient, Config config, DbVersionSupport dbVersionSupport) { - super(httpClient, config); - this.dbVersionSupport = dbVersionSupport; - } - - public TenantsUpdater withClassName(String className) { - this.className = className; - return this; - } - - public TenantsUpdater withTenants(Tenant... tenants) { - this.tenants = tenants; - return this; - } - - @Override - public Result run() { - if (dbVersionSupport.supportsOnly100TenantsInOneRequest() && tenants != null && tenants.length > BATCH_SIZE) { - for (List batch : chunkTenants(tenants, BATCH_SIZE)) { - Result resp = updateTenants(batch.toArray(new Tenant[0])); - if (resp.hasErrors()) { - return resp; - } - } - return new Result<>(200, true, null); - } - return updateTenants(tenants); - } - - private Result updateTenants(Tenant[] tenants) { - String path = String.format("/schema/%s/tenants", UrlEncoder.encodePathParam(className)); - Response resp = sendPutRequest(path, tenants, Tenant[].class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == HttpStatus.SC_OK, resp.getErrors()); - } - - private Collection> chunkTenants(Tenant[] tenants, int chunkSize) { - AtomicInteger counter = new AtomicInteger(); - return Stream.of(tenants).collect(Collectors.groupingBy(it -> counter.getAndIncrement() / chunkSize)).values(); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/api/VectorAdder.java b/src/main/java/io/weaviate/client/v1/schema/api/VectorAdder.java deleted file mode 100644 index 85968c905..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/api/VectorAdder.java +++ /dev/null @@ -1,67 +0,0 @@ -package io.weaviate.client.v1.schema.api; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.base.util.UrlEncoder; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.client.v1.schema.model.WeaviateClass.VectorConfig; - -public class VectorAdder extends BaseClient implements ClientResult { - private final ClassGetter getter; - - private String className; - private Map addedVectors = new HashMap<>(); - - public VectorAdder(HttpClient httpClient, Config config) { - super(httpClient, config); - this.getter = new ClassGetter(httpClient, config); - } - - public VectorAdder withClassName(String className) { - this.className = className; - return this; - } - - /** - * Add a named vectors. This method can be chained to add multiple named vectors - * without using a {@link Map}. - */ - public VectorAdder withVectorConfig(String name, VectorConfig vector) { - this.addedVectors.put(name, vector); - return this; - } - - /** - * Add all vectors from the map. This will overwrite any vectors added - * previously. - */ - public VectorAdder withVectorConfig(Map vectors) { - this.addedVectors = Collections.unmodifiableMap(vectors); - return this; - } - - @Override - public Result run() { - Result result = getter.withClassName(className).run(); - if (result.hasErrors()) { - result.toErrorResult(); - } - - WeaviateClass cls = result.getResult(); - addedVectors.entrySet().stream() - .forEach(vector -> cls.getVectorConfig() - .putIfAbsent(vector.getKey(), vector.getValue())); - - String path = String.format("/schema/%s", UrlEncoder.encodePathParam(className)); - Response resp = sendPutRequest(path, cls, WeaviateClass.class); - return new Result<>(resp.getStatusCode(), resp.getStatusCode() == 200, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/ActivityStatus.java b/src/main/java/io/weaviate/client/v1/schema/model/ActivityStatus.java deleted file mode 100644 index 171d017e8..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/ActivityStatus.java +++ /dev/null @@ -1,16 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -public interface ActivityStatus { - @Deprecated - String WARM = "WARM"; - String HOT = "HOT"; - String COLD = "COLD"; - String FROZEN = "FROZEN"; - String FREEZING = "FREEZING"; - String UNFREEZING = "UNFREEZING"; - String ACTIVE = "ACTIVE"; - String INACTIVE = "INACTIVE"; - String OFFLOADED = "OFFLOADED"; - String OFFLOADING = "OFFLOADING"; - String ONLOADING = "ONLOADING"; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/DataType.java b/src/main/java/io/weaviate/client/v1/schema/model/DataType.java deleted file mode 100644 index 8ab2b2d7a..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/DataType.java +++ /dev/null @@ -1,35 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -public interface DataType { - String CREF = "cref"; - /** - * As of Weaviate v1.19 'string' is deprecated and replaced by 'text'.
- * See data types - */ - @Deprecated - String STRING = "string"; - String TEXT = "text"; - String INT = "int"; - String NUMBER = "number"; - String BOOLEAN = "boolean"; - String DATE = "date"; - String GEO_COORDINATES = "geoCoordinates"; - String PHONE_NUMBER = "phoneNumber"; - String UUID = "uuid"; - String OBJECT = "object"; - String BLOB = "blob"; - - /** - * As of Weaviate v1.19 'string[]' is deprecated and replaced by 'text[]'.
- * See data types - */ - @Deprecated - String STRING_ARRAY = "string[]"; - String TEXT_ARRAY = "text[]"; - String INT_ARRAY = "int[]"; - String NUMBER_ARRAY = "number[]"; - String BOOLEAN_ARRAY = "boolean[]"; - String DATE_ARRAY = "date[]"; - String UUID_ARRAY = "uuid[]"; - String OBJECT_ARRAY = "object[]"; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/Property.java b/src/main/java/io/weaviate/client/v1/schema/model/Property.java deleted file mode 100644 index 0e38d6c6b..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/Property.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import java.util.List; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Property { - String name; - List dataType; - String description; - String tokenization; - /** - * As of Weaviate v1.19 'indexInverted' is deprecated and replaced by 'indexFilterable' - * and 'indexSearchable'.
- * See inverted index - */ - @Deprecated - Boolean indexInverted; - Boolean indexFilterable; - Boolean indexSearchable; - Boolean indexRangeFilters; - Object moduleConfig; - List nestedProperties; - - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class NestedProperty { - String name; - List dataType; - String description; - String tokenization; - Boolean indexFilterable; - Boolean indexSearchable; - Boolean indexRangeFilters; - List nestedProperties; - } -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/Schema.java b/src/main/java/io/weaviate/client/v1/schema/model/Schema.java deleted file mode 100644 index bba1b14b7..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/Schema.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import java.util.List; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Schema { - String name; - String maintainer; - List classes; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/Shard.java b/src/main/java/io/weaviate/client/v1/schema/model/Shard.java deleted file mode 100644 index bb7bbf232..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/Shard.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Shard { - String name; - String status; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/ShardStatus.java b/src/main/java/io/weaviate/client/v1/schema/model/ShardStatus.java deleted file mode 100644 index cee44cfa8..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/ShardStatus.java +++ /dev/null @@ -1,17 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Builder -@Getter -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class ShardStatus { - String status; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/ShardStatuses.java b/src/main/java/io/weaviate/client/v1/schema/model/ShardStatuses.java deleted file mode 100644 index 1e9d58f9a..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/ShardStatuses.java +++ /dev/null @@ -1,6 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -public interface ShardStatuses { - String READONLY = "READONLY"; - String READY = "READY"; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/Tenant.java b/src/main/java/io/weaviate/client/v1/schema/model/Tenant.java deleted file mode 100644 index cdf36e896..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/Tenant.java +++ /dev/null @@ -1,18 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class Tenant { - String name; - String activityStatus; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/Tokenization.java b/src/main/java/io/weaviate/client/v1/schema/model/Tokenization.java deleted file mode 100644 index d738ffbe8..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/Tokenization.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -public interface Tokenization { - String WORD = "word"; - String FIELD = "field"; - String WHITESPACE = "whitespace"; - String LOWERCASE = "lowercase"; -} diff --git a/src/main/java/io/weaviate/client/v1/schema/model/WeaviateClass.java b/src/main/java/io/weaviate/client/v1/schema/model/WeaviateClass.java deleted file mode 100644 index 792f60f84..000000000 --- a/src/main/java/io/weaviate/client/v1/schema/model/WeaviateClass.java +++ /dev/null @@ -1,61 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import com.google.gson.annotations.SerializedName; -import io.weaviate.client.v1.misc.model.InvertedIndexConfig; -import io.weaviate.client.v1.misc.model.MultiTenancyConfig; -import io.weaviate.client.v1.misc.model.ReplicationConfig; -import io.weaviate.client.v1.misc.model.ShardingConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import lombok.AccessLevel; -import lombok.Builder; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; -import lombok.experimental.FieldDefaults; - -import java.util.List; -import java.util.Map; - -@Getter -@Builder -@ToString -@EqualsAndHashCode -@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) -public class WeaviateClass { - @SerializedName("class") - String className; - String description; - InvertedIndexConfig invertedIndexConfig; - Object moduleConfig; - List properties; - VectorIndexConfig vectorIndexConfig; - ShardingConfig shardingConfig; - String vectorIndexType; - String vectorizer; - ReplicationConfig replicationConfig; - MultiTenancyConfig multiTenancyConfig; - Map vectorConfig; - - - public static class WeaviateClassBuilder { - - private Object moduleConfig; - - @Deprecated - public WeaviateClassBuilder ModuleConfig(Object moduleConfig) { - this.moduleConfig = moduleConfig; - return this; - } - } - - @Getter - @Builder - @ToString - @EqualsAndHashCode - @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) - public static class VectorConfig { - VectorIndexConfig vectorIndexConfig; - String vectorIndexType; - Map vectorizer; - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/DbUsers.java b/src/main/java/io/weaviate/client/v1/users/DbUsers.java deleted file mode 100644 index fefd9cb3d..000000000 --- a/src/main/java/io/weaviate/client/v1/users/DbUsers.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.weaviate.client.v1.users; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.api.RoleAssigner; -import io.weaviate.client.v1.users.api.RoleRevoker; -import io.weaviate.client.v1.users.api.common.AssignedRolesGetter; -import io.weaviate.client.v1.users.api.db.Activator; -import io.weaviate.client.v1.users.api.db.AllGetter; -import io.weaviate.client.v1.users.api.db.ByNameGetter; -import io.weaviate.client.v1.users.api.db.Creator; -import io.weaviate.client.v1.users.api.db.Deactivator; -import io.weaviate.client.v1.users.api.db.Deleter; -import io.weaviate.client.v1.users.api.db.KeyRotator; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class DbUsers { - private static final String USER_TYPE = "db"; - - private final HttpClient httpClient; - private final Config config; - - /** Assign a role to a user. Note that 'root' cannot be assigned. */ - public RoleAssigner assigner() { - return new RoleAssigner(httpClient, config, USER_TYPE); - } - - /** Revoke a role from a user. Note that 'root' cannot be revoked. */ - public RoleRevoker revoker() { - return new RoleRevoker(httpClient, config, USER_TYPE); - } - - /** Get roles assigned to a user. */ - public AssignedRolesGetter userRolesGetter() { - return new AssignedRolesGetter(httpClient, config, USER_TYPE); - } - - /** Create a new user. Returns API key for the user to authenticate by. */ - public Creator creator() { - return new Creator(httpClient, config); - } - - /** - * Delete user. - * Users declared in the server environment config cannot be - * deleted ('db_env_user'). - */ - public Deleter deleter() { - return new Deleter(httpClient, config); - } - - /** Activate user account. */ - public Activator activator() { - return new Activator(httpClient, config); - } - - /** Deactivate user account, optionally revoking its API key. */ - public Deactivator deactivator() { - return new Deactivator(httpClient, config); - } - - /** Rotate user's API key. The old key will become invalid. */ - public KeyRotator keyRotator() { - return new KeyRotator(httpClient, config); - } - - /** Get information about the user. */ - public ByNameGetter getUser() { - return new ByNameGetter(httpClient, config); - } - - /** List all known (non-OIDC) users. */ - public AllGetter allGetter() { - return new AllGetter(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/OidcUsers.java b/src/main/java/io/weaviate/client/v1/users/OidcUsers.java deleted file mode 100644 index 8616207e8..000000000 --- a/src/main/java/io/weaviate/client/v1/users/OidcUsers.java +++ /dev/null @@ -1,31 +0,0 @@ -package io.weaviate.client.v1.users; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.api.RoleAssigner; -import io.weaviate.client.v1.users.api.RoleRevoker; -import io.weaviate.client.v1.users.api.common.AssignedRolesGetter; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class OidcUsers { - private static final String USER_TYPE = "oidc"; - - private final HttpClient httpClient; - private final Config config; - - /** Assign a role to a user. Note that 'root' cannot be assigned. */ - public RoleAssigner assigner() { - return new RoleAssigner(httpClient, config, USER_TYPE); - } - - /** Revoke a role from a user. Note that 'root' cannot be revoked. */ - public RoleRevoker revoker() { - return new RoleRevoker(httpClient, config, USER_TYPE); - } - - /** Get roles assigned to a user. */ - public AssignedRolesGetter userRolesGetter() { - return new AssignedRolesGetter(httpClient, config, USER_TYPE); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/Users.java b/src/main/java/io/weaviate/client/v1/users/Users.java deleted file mode 100644 index 5799c4193..000000000 --- a/src/main/java/io/weaviate/client/v1/users/Users.java +++ /dev/null @@ -1,64 +0,0 @@ -package io.weaviate.client.v1.users; - -import io.weaviate.client.Config; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.api.MyUserGetter; -import io.weaviate.client.v1.users.api.RoleAssigner; -import io.weaviate.client.v1.users.api.RoleRevoker; -import io.weaviate.client.v1.users.api.UserRolesGetter; -import lombok.RequiredArgsConstructor; - -@RequiredArgsConstructor -public class Users { - - private final HttpClient httpClient; - private final Config config; - - /** Get information about the current user. */ - public MyUserGetter myUserGetter() { - return new MyUserGetter(httpClient, config); - }; - - /** - * Get roles assigned to a user. - *

- * Deprecated - prefer {@link DbUsers#userRolesGetter()} or - * {@link OidcUsers#userRolesGetter()}. - */ - @Deprecated - public UserRolesGetter userRolesGetter() { - return new UserRolesGetter(httpClient, config); - }; - - /** - * Assign a role to a user. Note that 'root' cannot be assigned. - *

- * Deprecated - prefer {@link DbUsers#assigner()} or - * {@link OidcUsers#assigner()}. - */ - @Deprecated - public RoleAssigner assigner() { - return new RoleAssigner(httpClient, config); - } - - /** - * Revoke a role from a user. Note that 'root' cannot be revoked. - *

- * Deprecated - prefer {@link DbUsers#revoker()} or - * {@link OidcUsers#revoker()} - */ - @Deprecated - public RoleRevoker revoker() { - return new RoleRevoker(httpClient, config); - } - - /** Manage dynamic users, their roles and permissions. */ - public DbUsers db() { - return new DbUsers(httpClient, config); - } - - /** Manage users authenticated via OIDC, their roles and permissions. */ - public OidcUsers oidc() { - return new OidcUsers(httpClient, config); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/MyUserGetter.java b/src/main/java/io/weaviate/client/v1/users/api/MyUserGetter.java deleted file mode 100644 index 88bcf7222..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/MyUserGetter.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import java.util.Optional; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.model.User; - -public class MyUserGetter extends BaseClient implements ClientResult { - public MyUserGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result run() { - Response resp = sendGetRequest("/users/own-info", WeaviateUser.class); - User user = Optional.ofNullable(resp.getBody()).map(WeaviateUser::toUser).orElse(null); - return new Result<>(resp.getStatusCode(), user, resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/RoleAssigner.java b/src/main/java/io/weaviate/client/v1/users/api/RoleAssigner.java deleted file mode 100644 index b10710c43..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/RoleAssigner.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import lombok.AllArgsConstructor; - -public class RoleAssigner extends BaseClient implements ClientResult { - private String userId; - private List roles = new ArrayList<>(); - - private final String _userType; - - public RoleAssigner(HttpClient httpClient, Config config) { - this(httpClient, config, null); - } - - public RoleAssigner(HttpClient httpClient, Config config, String userType) { - super(httpClient, config); - this._userType = userType; - } - - public RoleAssigner withUserId(String id) { - this.userId = id; - return this; - } - - public RoleAssigner witRoles(String... roles) { - this.roles = Arrays.asList(roles); - return this; - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - final String userType = _userType; - final List roles; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest(path(), new Body(this.roles), Void.class)); - } - - private String path() { - return String.format("/authz/users/%s/assign", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/RoleRevoker.java b/src/main/java/io/weaviate/client/v1/users/api/RoleRevoker.java deleted file mode 100644 index 01a38d50c..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/RoleRevoker.java +++ /dev/null @@ -1,55 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import lombok.AllArgsConstructor; - -public class RoleRevoker extends BaseClient implements ClientResult { - private String userId; - private List roles = new ArrayList<>(); - - private final String _userType; - - public RoleRevoker(HttpClient httpClient, Config config) { - this(httpClient, config, null); - } - - public RoleRevoker(HttpClient httpClient, Config config, String userType) { - super(httpClient, config); - this._userType = userType; - } - - public RoleRevoker withUserId(String id) { - this.userId = id; - return this; - } - - public RoleRevoker witRoles(String... roles) { - this.roles = Collections.unmodifiableList(Arrays.asList(roles)); - return this; - } - - /** The API signature for this method is { "roles": [...] } */ - @AllArgsConstructor - private class Body { - final String userType = _userType; - final List roles; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest(path(), new Body(this.roles), Void.class)); - } - - private String path() { - return String.format("/authz/users/%s/revoke", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/UserRolesGetter.java b/src/main/java/io/weaviate/client/v1/users/api/UserRolesGetter.java deleted file mode 100644 index d76498eaf..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/UserRolesGetter.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class UserRolesGetter extends BaseClient implements ClientResult> { - private String userId; - - public UserRolesGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - /** Leave unset to fetch roles assigned to the current user. */ - public UserRolesGetter withUserId(String id) { - this.userId = id; - return this; - } - - @Override - public Result> run() { - Response resp = sendGetRequest(path(), WeaviateRole[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList).orElse(new ArrayList<>()) - .stream().map(WeaviateRole::toRole) - .collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - } - - private String path() { - return String.format("/authz/users/%s/roles", this.userId); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/WeaviateUser.java b/src/main/java/io/weaviate/client/v1/users/api/WeaviateUser.java deleted file mode 100644 index 84e18b80b..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/WeaviateUser.java +++ /dev/null @@ -1,29 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Collectors; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.users.model.User; - -public class WeaviateUser { - @SerializedName("username") - String username; - - @SerializedName("user_id") - String id; - - @SerializedName("roles") - List roles = new ArrayList<>(); - - public User toUser() { - return new User( - id != null ? id : username, - roles != null - ? roles.stream().map(WeaviateRole::toRole).collect(Collectors.toList()) - : new ArrayList<>()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/common/AssignedRolesGetter.java b/src/main/java/io/weaviate/client/v1/users/api/common/AssignedRolesGetter.java deleted file mode 100644 index be1a74f44..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/common/AssignedRolesGetter.java +++ /dev/null @@ -1,61 +0,0 @@ -package io.weaviate.client.v1.users.api.common; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.rbac.api.WeaviateRole; -import io.weaviate.client.v1.rbac.model.Role; - -public class AssignedRolesGetter extends BaseClient implements ClientResult> { - private String userId; - private boolean includePermissions = false; - private final String userType; - - public AssignedRolesGetter(HttpClient httpClient, Config config, String userType) { - super(httpClient, config); - this.userType = userType; - } - - public AssignedRolesGetter withUserId(String userId) { - this.userId = userId; - return this; - } - - /** - * Include a full list of permissions for each role. - * If not set, only role names will be populated. - */ - public AssignedRolesGetter includePermissions() { - return includePermissions(true); - } - - public AssignedRolesGetter includePermissions(boolean include) { - this.includePermissions = include; - return this; - } - - @Override - public Result> run() { - Response resp = sendGetRequest(path(), WeaviateRole[].class); - List roles = Optional.ofNullable(resp.getBody()) - .map(Arrays::asList).orElse(new ArrayList<>()) - .stream().map(WeaviateRole::toRole) - .collect(Collectors.toList()); - return new Result<>(resp.getStatusCode(), roles, resp.getErrors()); - - } - - private String path() { - return String.format("/authz/users/%s/roles/%s?includeFullRoles=%s", - userId, userType, includePermissions); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/Activator.java b/src/main/java/io/weaviate/client/v1/users/api/db/Activator.java deleted file mode 100644 index 8006b517c..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/Activator.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import org.apache.hc.core5.http.HttpStatus; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class Activator extends BaseClient implements ClientResult { - private String userId; - - public Activator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Activator withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest("/users/db/" + userId + "/activate", null, Void.class), - HttpStatus.SC_CONFLICT); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/AllGetter.java b/src/main/java/io/weaviate/client/v1/users/api/db/AllGetter.java deleted file mode 100644 index 08ef51164..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/AllGetter.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import java.util.Arrays; -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.model.UserDb; - -public class AllGetter extends BaseClient implements ClientResult> { - - public AllGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - @Override - public Result> run() { - Response resp = sendGetRequest("/users/db", UserDb[].class); - return new Result<>(resp.getStatusCode(), Arrays.asList(resp.getBody()), resp.getErrors()); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/ByNameGetter.java b/src/main/java/io/weaviate/client/v1/users/api/db/ByNameGetter.java deleted file mode 100644 index f5bbac746..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/ByNameGetter.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.model.UserDb; - -public class ByNameGetter extends BaseClient implements ClientResult { - private String userId; - - public ByNameGetter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public ByNameGetter withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Result run() { - return new Result<>(sendGetRequest("/users/db/" + userId, UserDb.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/Creator.java b/src/main/java/io/weaviate/client/v1/users/api/db/Creator.java deleted file mode 100644 index ca51e9f8a..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/Creator.java +++ /dev/null @@ -1,36 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.api.db.Creator.ApiKey; - -/** Creates a new 'db' user and returns its API key. */ -public class Creator extends BaseClient implements ClientResult { - private String userId; - - public Creator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Creator withUserId(String userId) { - this.userId = userId; - return this; - } - - static class ApiKey { - @SerializedName("apikey") - String apiKey; - } - - @Override - public Result run() { - Response resp = sendPostRequest("/users/db/" + userId, null, ApiKey.class); - return new Result<>(resp, resp.getBody() != null ? resp.getBody().apiKey : null); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/Deactivator.java b/src/main/java/io/weaviate/client/v1/users/api/db/Deactivator.java deleted file mode 100644 index 3305188ca..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/Deactivator.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import org.apache.hc.core5.http.HttpStatus; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import lombok.AllArgsConstructor; - -public class Deactivator extends BaseClient implements ClientResult { - private String userId; - private boolean revokeKey = false; - - public Deactivator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Deactivator withUserId(String userId) { - this.userId = userId; - return this; - } - - public Deactivator revokeKey() { - return revokeKey(true); - } - - public Deactivator revokeKey(boolean revoke) { - this.revokeKey = revoke; - return this; - } - - @AllArgsConstructor - private class Body { - @SerializedName("revoke_key") - private boolean revokeKey; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendPostRequest("/users/db/" + userId + "/deactivate", new Body(revokeKey), Void.class), - HttpStatus.SC_CONFLICT); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/Deleter.java b/src/main/java/io/weaviate/client/v1/users/api/db/Deleter.java deleted file mode 100644 index ae75a3db1..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/Deleter.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; - -public class Deleter extends BaseClient implements ClientResult { - private String userId; - - public Deleter(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public Deleter withUserId(String userId) { - this.userId = userId; - return this; - } - - @Override - public Result run() { - return Result.voidToBoolean(sendDeleteRequest("/users/db/" + userId, null, Void.class)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/api/db/KeyRotator.java b/src/main/java/io/weaviate/client/v1/users/api/db/KeyRotator.java deleted file mode 100644 index 90a453bb8..000000000 --- a/src/main/java/io/weaviate/client/v1/users/api/db/KeyRotator.java +++ /dev/null @@ -1,35 +0,0 @@ -package io.weaviate.client.v1.users.api.db; - -import com.google.gson.annotations.SerializedName; - -import io.weaviate.client.Config; -import io.weaviate.client.base.BaseClient; -import io.weaviate.client.base.ClientResult; -import io.weaviate.client.base.Response; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.http.HttpClient; -import io.weaviate.client.v1.users.api.db.KeyRotator.ApiKey; - -public class KeyRotator extends BaseClient implements ClientResult { - private String userId; - - public KeyRotator(HttpClient httpClient, Config config) { - super(httpClient, config); - } - - public KeyRotator withUserId(String userId) { - this.userId = userId; - return this; - } - - static class ApiKey { - @SerializedName("apikey") - String apiKey; - } - - @Override - public Result run() { - Response resp = sendPostRequest("/users/db/" + userId + "/rotate-key", null, ApiKey.class); - return new Result<>(resp, resp.getBody().apiKey); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/model/User.java b/src/main/java/io/weaviate/client/v1/users/model/User.java deleted file mode 100644 index 436eb4b13..000000000 --- a/src/main/java/io/weaviate/client/v1/users/model/User.java +++ /dev/null @@ -1,20 +0,0 @@ -package io.weaviate.client.v1.users.model; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -import io.weaviate.client.v1.rbac.model.Role; -import lombok.Getter; - -@Getter -public class User { - String userId; - Map roles = new HashMap<>(); - - public User(String id, List roles) { - this.userId = id; - this.roles = roles.stream().collect(Collectors.toMap(Role::getName, r -> r)); - } -} diff --git a/src/main/java/io/weaviate/client/v1/users/model/UserDb.java b/src/main/java/io/weaviate/client/v1/users/model/UserDb.java deleted file mode 100644 index 8c495f3b0..000000000 --- a/src/main/java/io/weaviate/client/v1/users/model/UserDb.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.client.v1.users.model; - -import java.util.List; - -import com.google.gson.annotations.SerializedName; - -import lombok.EqualsAndHashCode; -import lombok.Getter; - -@Getter -@EqualsAndHashCode -public class UserDb { - @SerializedName("roles") - List roleNames; - - @SerializedName("userId") - String userId; - - @SerializedName("dbUserType") - String userType; - - @SerializedName("active") - boolean active; -} diff --git a/src/main/java/io/weaviate/client6/v1/api/Authentication.java b/src/main/java/io/weaviate/client6/v1/api/Authentication.java new file mode 100644 index 000000000..1c8776c1c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/Authentication.java @@ -0,0 +1,78 @@ +package io.weaviate.client6.v1.api; + +import java.util.List; + +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.oidc.OidcConfig; +import io.weaviate.client6.v1.internal.oidc.OidcUtils; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public interface Authentication { + TokenProvider getTokenProvider(RestTransport transport); + + /** + * Authenticate using a static API key. + * + * @param apiKey Weaviate API key. + */ + public static Authentication apiKey(String apiKey) { + return __ -> TokenProvider.staticToken(apiKey); + } + + /** + * Authenticate using an existing access_token + refresh_token + * pair. + * + * @param accessToken Access token. + * @param refreshToken Refresh token. + * @param expiresIn Remaining token lifetime in seconds. + * + * @return Authentication provider. + * @throws WeaviateOAuthException if an error occurred at any point of the + * exchange process. + */ + public static Authentication bearerToken(String accessToken, String refreshToken, long expiresIn) { + return transport -> { + OidcConfig oidc = OidcUtils.getConfig(transport); + return TokenProvider.bearerToken(oidc, accessToken, refreshToken, expiresIn); + }; + } + + /** + * Authenticate using Resource Owner Password authorization grant. + * + * @param username Resource owner username. + * @param password Resource owner password. + * @param scopes Client scopes. + * + * @return Authentication provider. + * @throws WeaviateOAuthException if an error occurred at any point of the token + * exchange process. + */ + public static Authentication resourceOwnerPassword(String username, String password, List scopes) { + return transport -> { + OidcConfig oidc = OidcUtils.getConfig(transport).withScopes(scopes).withScopes("offline_access"); + return TokenProvider.resourceOwnerPassword(oidc, username, password); + }; + } + + /** + * Authenticate using Client Credentials authorization grant. + * + * @param clientSecret Client secret. + * @param scopes Client scopes. + * + * @return Authentication provider. + * @throws WeaviateOAuthException if an error occurred at any point while + * obtaining a new token. + */ + public static Authentication clientCredentials(String clientSecret, List scopes) { + return transport -> { + OidcConfig oidc = OidcUtils.getConfig(transport).withScopes(scopes); + if (oidc.scopes().isEmpty() && TokenProvider.isMicrosoft(oidc)) { + oidc = oidc.withScopes(oidc.clientId() + "/.default"); + } + return TokenProvider.clientCredentials(oidc, clientSecret); + }; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/Config.java b/src/main/java/io/weaviate/client6/v1/api/Config.java new file mode 100644 index 000000000..b52b37066 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/Config.java @@ -0,0 +1,367 @@ +package io.weaviate.client6.v1.api; + +import java.net.URI; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; + +import javax.net.ssl.TrustManagerFactory; + +import io.weaviate.client6.v1.internal.BuildInfo; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.grpc.GrpcChannelOptions; +import io.weaviate.client6.v1.internal.rest.RestTransportOptions; + +public record Config( + String scheme, + String httpHost, + int httpPort, + String grpcHost, + int grpcPort, + Map headers, + Authentication authentication, + TrustManagerFactory trustManagerFactory, + Timeout timeout) { + + public static Config of(Function> fn) { + return fn.apply(new Custom()).build(); + } + + private Config(Builder builder) { + this( + builder.scheme, + builder.httpHost, + builder.httpPort, + builder.grpcHost, + builder.grpcPort, + builder.headers, + builder.authentication, + builder.trustManagerFactory, + builder.timeout); + } + + RestTransportOptions restTransportOptions() { + return restTransportOptions(null); + } + + RestTransportOptions restTransportOptions(TokenProvider tokenProvider) { + return new RestTransportOptions(scheme, httpHost, httpPort, headers, tokenProvider, trustManagerFactory, timeout); + } + + GrpcChannelOptions grpcTransportOptions() { + return grpcTransportOptions(null); + } + + GrpcChannelOptions grpcTransportOptions(TokenProvider tokenProvider) { + return new GrpcChannelOptions(scheme, grpcHost, grpcPort, headers, tokenProvider, trustManagerFactory, timeout); + } + + private abstract static class Builder> implements ObjectBuilder { + protected String scheme; + + protected String httpHost; + protected int httpPort; + protected String grpcHost; + protected int grpcPort; + protected Authentication authentication; + protected TrustManagerFactory trustManagerFactory; + protected Timeout timeout = new Timeout(); + protected Map headers = new HashMap<>(); + + /** + * Set URL scheme. Subclasses may increase the visibility of this method to + * {@code public} if using a different scheme is allowed. + */ + @SuppressWarnings("unchecked") + protected SelfT scheme(String scheme) { + this.scheme = scheme; + return (SelfT) this; + } + + /** + * Set port for REST requests. Subclasses may increase the visibility of this + * method to {@code public} if using a different port is allowed. + */ + @SuppressWarnings("unchecked") + protected SelfT httpHost(String httpHost) { + this.httpHost = trimScheme(httpHost); + return (SelfT) this; + } + + /** + * Set port for gRPC requests. Subclasses may increase the visibility of this + * method to {@code public} if using a different port is allowed. + */ + @SuppressWarnings("unchecked") + protected SelfT grpcHost(String grpcHost) { + this.grpcHost = trimScheme(grpcHost); + return (SelfT) this; + } + + /** Remove leading http(s):// prefix from a URL, if present. */ + private String trimScheme(String url) { + return url.replaceFirst("^https?\\/\\/", ""); + } + + /** + * Provide a {@link TrustManagerFactory}. Subclasses which support + * secure connection should expose this method. + */ + @SuppressWarnings("unchecked") + protected SelfT trustManagerFactory(TrustManagerFactory tmf) { + this.trustManagerFactory = tmf; + return (SelfT) this; + } + + /** + * Set authentication method. Setting this to {@code null} or omitting + * will not use any authentication mechanism. + */ + @SuppressWarnings("unchecked") + public SelfT authentication(Authentication authz) { + this.authentication = authz; + return (SelfT) this; + } + + /** + * Set a single request header. The client does not support header lists, + * so there is no equivalent {@code addHeader} to append to existing header. + * This will be applied both to REST and gRPC requests. + */ + @SuppressWarnings("unchecked") + public SelfT setHeader(String key, String value) { + this.headers.put(key, value); + return (SelfT) this; + } + + /** + * Set multiple request headers. + * This will be applied both to REST and gRPC requests. + */ + @SuppressWarnings("unchecked") + public SelfT setHeaders(Map headers) { + this.headers.putAll(Map.copyOf(headers)); + return (SelfT) this; + } + + /** + * Set connection, query, and insert timeout to the same value. + * + * @param timeoutSeconds Response timeout in seconds. + */ + @SuppressWarnings("unchecked") + public SelfT timeout(int timeoutSeconds) { + this.timeout = new Timeout(timeoutSeconds); + return (SelfT) this; + } + + /** + * Set individual connection, query, and insert timeouts. + * + *

+ * Because all inserts go over gRPC connection, the REST requests + * will assume {@code querySeconds} timeouts. + * + * @param initSeconds Connection timeout in seconds. + * @param querySeconds Response timeout for query requests. + * @param insertSeconds Response timeout for insert requests. + */ + @SuppressWarnings("unchecked") + public SelfT timeout(int initSeconds, int querySeconds, int insertSeconds) { + this.timeout = new Timeout(initSeconds, querySeconds, insertSeconds); + return (SelfT) this; + } + + /** + * Weaviate will use the URL in this header to call Weaviate Embeddings + * Service if an appropriate vectorizer is configured for collection. + */ + private static final String HEADER_X_WEAVIATE_CLUSTER_URL = "X-Weaviate-Cluster-URL"; + private static final String HEADER_X_WEAVIATE_CLIENT = "X-Weaviate-Client"; + + /** + * isWeaviateDomain returns true if the host matches weaviate.io, + * semi.technology, or weaviate.cloud domain. + */ + private static boolean isWeaviateDomain(String host) { + var lower = host.toLowerCase(); + return lower.contains("weaviate.io") || + lower.contains("semi.technology") || + lower.contains("weaviate.cloud"); + } + + private static final String VERSION = "weaviate-client-java/" + + ((!BuildInfo.TAGS.isBlank() && BuildInfo.TAGS != "unknown") ? BuildInfo.TAGS + : (BuildInfo.BRANCH + "-" + BuildInfo.COMMIT_ID_ABBREV)); + + @Override + public Config build() { + // For clusters hosted on Weaviate Cloud, Weaviate Embedding Service + // will be available under the same domain. + if (isWeaviateDomain(httpHost) && authentication != null) { + setHeader(HEADER_X_WEAVIATE_CLUSTER_URL, "https://" + httpHost + ":" + httpPort); + } + setHeader(HEADER_X_WEAVIATE_CLIENT, VERSION); + return new Config(this); + } + } + + /** + * Configuration for Weaviate instances deployed locally. + * + *

+ * Has sane defaults that match standard Weaviate deployment configuration: + *

    + *
  • {@code scheme: http}
  • + *
  • {@code host: localhost}
  • + *
  • {@code httpPort: 8080}
  • + *
  • {@code grpcPort: 50051}
  • + *
+ */ + public static class Local extends Builder { + public Local() { + scheme("http"); + host("localhost"); + port(8080); + grpcPort(50051); + } + + /** + * Set a different hostname. + * This changes both {@code httpHost} and {@code grpcHost}. + */ + public Local host(String host) { + httpHost(host); + grpcHost(host); + return this; + } + + /** Override default HTTP port. */ + public Local port(int port) { + this.httpPort = port; + return this; + } + + /** Override default gRPC port. */ + public Local grpcPort(int port) { + this.grpcPort = port; + return this; + } + } + + /** + * Configuration for instances hosted on Weaviate Cloud. + * {@link WeaviateCloud} will create a secure client + * with {@code schema: https} and {@code http-/grpcPort: 443}. + * + * Custom SSL certificates are suppored via + * {@link #trustManagerFactory}. + */ + public static class WeaviateCloud extends Builder { + public WeaviateCloud(String httpHost, Authentication authentication) { + this(URI.create(httpHost), authentication); + } + + public WeaviateCloud(URI clusterUri, Authentication authentication) { + scheme("https"); + super.httpHost(clusterUri.getHost() != null + ? clusterUri.getHost() // https://[example.com]/about + : clusterUri.getPath().split("/")[0]); // [example.com]/about + super.grpcHost("grpc-" + this.httpHost); + this.httpPort = 443; + this.grpcPort = 443; + this.authentication = authentication; + } + + /** + * Configure a custom TrustStore to validate third-party SSL certificates. + * + *

+ * Usage: + * + *

{@code
+     * // Create a TrustManagerFactory to validate custom certificates.
+     * TrustManagerFactory tmf;
+     * try (var keys = new FileInputStream("/path/to/custom/truststore.p12")) {
+     *   KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+     *   trustStore.load(myKeys, "secret-password".toCharArra());
+     *
+     *   tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+     *   tmf.init(trustStore);
+     * }
+     *
+     * // Pass it to wcd -> wcd.trustManagerFactory(tmf)
+     * }
+ */ + public WeaviateCloud trustManagerFactory(TrustManagerFactory tmf) { + return super.trustManagerFactory(tmf); + } + } + + /** Configuration for custom Weaviate deployements. */ + public static class Custom extends Builder { + /** + * Scheme controls which protocol will be used for the database connection. + * REST and gRPC ports will be automatically inferred from it: + * 443 for HTTPS connection and 80 for HTTP. + * + * These can be overriden with {@link #httpPort(int)} and + * {@link #grpcPort(int)}. + */ + public Custom scheme(String scheme) { + httpPort("https".equals(scheme) ? 443 : 80); + grpcPort("https".equals(scheme) ? 443 : 80); + return super.scheme(scheme); + } + + /** Set HTTP hostname. */ + public Custom httpHost(String httpHost) { + super.httpHost(httpHost); + return this; + } + + /** Set HTTP port. */ + public Custom httpPort(int port) { + this.httpPort = port; + return this; + } + + /** Set gRPC hostname. */ + public Custom grpcHost(String grpcHost) { + super.grpcHost(grpcHost); + return this; + } + + /** Set gRPC port. */ + public Custom grpcPort(int port) { + this.grpcPort = port; + return this; + } + + /** + * Configure a custom TrustStore to validate third-party SSL certificates. + * + *

+ * Usage: + * + *

{@code
+     * // Create a TrustManagerFactory to validate custom certificates.
+     * TrustManagerFactory tmf;
+     * try (var keys = new FileInputStream("/path/to/custom/truststore.p12")) {
+     *   KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+     *   trustStore.load(myKeys, "secret-password".toCharArra());
+     *
+     *   tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+     *   tmf.init(trustStore);
+     * }
+     *
+     * // Pass it to custom -> custom.trustManagerFactory(tmf)
+     * }
+ */ + public Custom trustManagerFactory(TrustManagerFactory tmf) { + return super.trustManagerFactory(tmf); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/InstanceMetadata.java b/src/main/java/io/weaviate/client6/v1/api/InstanceMetadata.java new file mode 100644 index 000000000..c3ce05765 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/InstanceMetadata.java @@ -0,0 +1,12 @@ +package io.weaviate.client6.v1.api; + +import java.util.Map; + +import com.google.gson.annotations.SerializedName; + +public record InstanceMetadata( + @SerializedName("hostname") String hostName, + @SerializedName("version") String version, + @SerializedName("modules") Map modules, + @SerializedName("grpcMaxMessageSize") Integer grpcMaxMessageSize) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/InstanceMetadataRequest.java b/src/main/java/io/weaviate/client6/v1/api/InstanceMetadataRequest.java new file mode 100644 index 000000000..09635c9df --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/InstanceMetadataRequest.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.api; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public class InstanceMetadataRequest { + public static final Endpoint _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + __ -> "/meta", + __ -> Collections.emptyMap(), + InstanceMetadata.class); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/IsLiveRequest.java b/src/main/java/io/weaviate/client6/v1/api/IsLiveRequest.java new file mode 100644 index 000000000..e098a6e09 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/IsLiveRequest.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; + +public record IsLiveRequest() { + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + request -> "GET", + request -> "/.well-known/live", + request -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/IsReadyRequest.java b/src/main/java/io/weaviate/client6/v1/api/IsReadyRequest.java new file mode 100644 index 000000000..bc597f8ca --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/IsReadyRequest.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; + +public record IsReadyRequest() { + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + request -> "GET", + request -> "/.well-known/ready", + request -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateApiException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateApiException.java new file mode 100644 index 000000000..ee029da54 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateApiException.java @@ -0,0 +1,79 @@ +package io.weaviate.client6.v1.api; + +/** + * Exception class thrown by client when the request had reached the + * server, but the operation did not complete successfully either + * due to a bad request or a server error. + */ +public class WeaviateApiException extends WeaviateException { + private final String errorMessage; + private final Source source; + private final String endpoint; + private final Integer httpStatusCode; + private final io.grpc.Status.Code grpcStatusCode; + + private enum Source { + HTTP, GRPC; + }; + + public static WeaviateApiException http(String method, String endpoint, int statusCode, String errorMessage) { + return new WeaviateApiException(method, endpoint, statusCode, errorMessage); + } + + public static WeaviateApiException gRPC(io.grpc.StatusRuntimeException ex) { + var status = ex.getStatus(); + return new WeaviateApiException(status.getCode(), status.getDescription()); + } + + private WeaviateApiException(io.grpc.Status.Code code, String errorMessage) { + super("%s: %s".formatted(code, errorMessage)); + this.source = Source.GRPC; + this.errorMessage = errorMessage; + this.grpcStatusCode = code; + this.endpoint = null; + this.httpStatusCode = null; + } + + private WeaviateApiException(String method, String endpoint, int statusCode, String errorMessage) { + super("HTTP %d: %s %s: %s".formatted(statusCode, method, endpoint, errorMessage)); + this.source = Source.HTTP; + this.errorMessage = errorMessage; + this.endpoint = endpoint; + this.httpStatusCode = statusCode; + this.grpcStatusCode = null; + } + + /** Get raw error message. */ + public String getError() { + return errorMessage; + } + + /** Check if the exception originates from the gRPC transport. */ + public boolean isGPRC() { + return source == Source.GRPC; + } + + /** Get the gRPC status code. */ + public String grpcStatusCode() { + if (!isGPRC()) { + return null; + } + return grpcStatusCode.toString(); + } + + /** Check if the exception originates from the HTTP transport. */ + public boolean isHTTP() { + return source == Source.HTTP; + } + + /** Get the endpoint that the failed request was sent to. */ + public String endpoint() { + return endpoint; + } + + /** Get the HTTP status code. */ + public Integer httpStatusCode() { + return httpStatusCode; + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateClient.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateClient.java new file mode 100644 index 000000000..63e14c3bf --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateClient.java @@ -0,0 +1,224 @@ +package io.weaviate.client6.v1.api; + +import java.io.IOException; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.alias.WeaviateAliasClient; +import io.weaviate.client6.v1.api.backup.WeaviateBackupClient; +import io.weaviate.client6.v1.api.cluster.WeaviateClusterClient; +import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClient; +import io.weaviate.client6.v1.api.rbac.groups.WeaviateGroupsClient; +import io.weaviate.client6.v1.api.rbac.roles.WeaviateRolesClient; +import io.weaviate.client6.v1.api.rbac.users.WeaviateUsersClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.VersionSupport; +import io.weaviate.client6.v1.internal.grpc.DefaultGrpcTransport; +import io.weaviate.client6.v1.internal.grpc.GrpcChannelOptions; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.rest.DefaultRestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransportOptions; + +public class WeaviateClient implements AutoCloseable { + /** Store this for {@link #async()} helper. */ + private final Config config; + + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + /** + * Client for {@code /schema} endpoints for managing Weaviate collections. + * See {@link WeaviateCollectionsClient#use} for populating and querying + * collections. + */ + public final WeaviateCollectionsClient collections; + + /** Client for {@code /aliases} endpoints for managing collection aliases. */ + public final WeaviateAliasClient alias; + + /** Client for {@code /backups} endpoints for managing backups. */ + public final WeaviateBackupClient backup; + + /** + * Client for {@code /authz/roles} endpoints for managing RBAC roles. + */ + public final WeaviateRolesClient roles; + + /** + * Client for {@code /authz/groups} endpoints for managing RBAC groups. + */ + public final WeaviateGroupsClient groups; + + /** + * Client for {@code /users} endpoints for managing DB / OIDC users. + */ + public final WeaviateUsersClient users; + + /** + * Client for {@code /nodes} and {@code /replication} endpoints + * for managing replication and sharding. + */ + public final WeaviateClusterClient cluster; + + public WeaviateClient(Config config) { + RestTransportOptions restOpt; + GrpcChannelOptions grpcOpt; + if (config.authentication() == null) { + restOpt = config.restTransportOptions(); + grpcOpt = config.grpcTransportOptions(); + } else { + TokenProvider tokenProvider; + try (final var noAuthRest = new DefaultRestTransport(config.restTransportOptions())) { + tokenProvider = config.authentication().getTokenProvider(noAuthRest); + } catch (Exception e) { + // Generally exceptions are caught in TokenProvider internals. + // This one may be thrown when noAuthRest transport is auto-closed. + throw new WeaviateOAuthException(e); + } + restOpt = config.restTransportOptions(tokenProvider); + grpcOpt = config.grpcTransportOptions(tokenProvider); + } + + // Initialize REST transport to a temporary variable to dispose of + // the associated resources in case we have to throw an exception. + // Assign to this.restTransport only once we're in the clear to + // avoid publishing the object before it's fully initialized. + var _restTransport = new DefaultRestTransport(restOpt.withTimeout( + new Timeout(restOpt.timeout().initSeconds()))); + boolean isLive = false; + InstanceMetadata meta = null; + try { + isLive = _restTransport.performRequest(null, IsLiveRequest._ENDPOINT); + meta = _restTransport.performRequest(null, InstanceMetadataRequest._ENDPOINT); + } catch (IOException e) { + throw new WeaviateConnectException(e); + } + + if (!isLive) { + var ex = new WeaviateConnectException("Weaviate not available at " + restOpt.baseUrl()); + try { + _restTransport.close(); + } catch (Exception e) { + ex.addSuppressed(e); + } + throw ex; + } + + if (!VersionSupport.isSupported(meta.version())) { + throw new WeaviateUnsupportedVersionException(meta.version()); + } + + if (meta.grpcMaxMessageSize() != null) { + grpcOpt = grpcOpt.withMaxMessageSize(meta.grpcMaxMessageSize()); + } + + this.restTransport = _restTransport; + this.grpcTransport = new DefaultGrpcTransport(grpcOpt); + this.alias = new WeaviateAliasClient(restTransport); + this.backup = new WeaviateBackupClient(restTransport); + this.collections = new WeaviateCollectionsClient(restTransport, grpcTransport); + this.roles = new WeaviateRolesClient(restTransport); + this.groups = new WeaviateGroupsClient(restTransport); + this.users = new WeaviateUsersClient(restTransport); + this.cluster = new WeaviateClusterClient(restTransport); + this.config = config; + } + + /** + * Create {@link WeaviateClientAsync} with identical configurations. + * It is a shorthand for: + * + *
{@code
+   * var config = new Config(...);
+   * var client = new WeaviateClient(config);
+   * var async = new WeaviateClientAsync(config);
+   * }
+ * + * and as such, this does not manage or reuse resources (transport, gRPC + * channel, etc) used by the original client. Keep that in mind and make + * sure to close the original and async clients individually. + * + *

+ * Example: + * + *

{@code
+   * var client = WeaviateClient.connectToLocal();
+   *
+   * // Need to make the next request non-blocking
+   * try (final var async = client.async()) {
+   *   async.collections.create("Things");
+   * }
+   * // At this point only `async` resource has been auto-closed.
+   *
+   * client.close();
+   * }
+ * + * + * If you only intend to use {@link WeaviateClientAsync}, prefer creating it + * directly via one of its static factories: + *
    + *
  • {@link WeaviateClientAsync#connectToLocal} + *
  • {@link WeaviateClientAsync#connectToWeaviateCloud} + *
  • {@link WeaviateClientAsync#connectToCustom} + *
+ * + * Otherwise the client wastes time initializing resources it will never use. + */ + public WeaviateClientAsync async() { + return new WeaviateClientAsync(config); + } + + /** Connect to a local Weaviate instance. */ + public static WeaviateClient connectToLocal() { + return connectToLocal(ObjectBuilder.identity()); + } + + /** Connect to a local Weaviate instance. */ + public static WeaviateClient connectToLocal(Function> fn) { + return new WeaviateClient(fn.apply(new Config.Local()).build()); + } + + /** Connect to a Weaviate Cloud instance. */ + public static WeaviateClient connectToWeaviateCloud(String httpHost, String apiKey) { + return connectToWeaviateCloud(httpHost, apiKey, ObjectBuilder.identity()); + } + + /** Connect to a Weaviate Cloud instance. */ + public static WeaviateClient connectToWeaviateCloud(String httpHost, String apiKey, + Function> fn) { + var config = new Config.WeaviateCloud(httpHost, Authentication.apiKey(apiKey)); + return new WeaviateClient(fn.apply(config).build()); + } + + /** Connect to a Weaviate instance with custom configuration. */ + public static WeaviateClient connectToCustom(Function> fn) { + return new WeaviateClient(fn.apply(new Config.Custom()).build()); + } + + /** Ping the server for a liveness check. */ + public boolean isLive() throws IOException { + return this.restTransport.performRequest(null, IsLiveRequest._ENDPOINT); + } + + /** Ping the server for a readiness check. */ + public boolean isReady() throws IOException { + return this.restTransport.performRequest(null, IsReadyRequest._ENDPOINT); + } + + /** Get deployement metadata for the target Weaviate instance. */ + public InstanceMetadata meta() throws IOException { + return this.restTransport.performRequest(null, InstanceMetadataRequest._ENDPOINT); + } + + /** + * Close {@link #restTransport} and {@link #grpcTransport} + * and release associated resources. + */ + @Override + public void close() throws Exception { + this.restTransport.close(); + this.grpcTransport.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateClientAsync.java new file mode 100644 index 000000000..b38cd20d2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateClientAsync.java @@ -0,0 +1,212 @@ +package io.weaviate.client6.v1.api; + +import java.io.IOException; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.alias.WeaviateAliasClientAsync; +import io.weaviate.client6.v1.api.backup.WeaviateBackupClientAsync; +import io.weaviate.client6.v1.api.cluster.WeaviateClusterClientAsync; +import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClient; +import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClientAsync; +import io.weaviate.client6.v1.api.rbac.groups.WeaviateGroupsClientAsync; +import io.weaviate.client6.v1.api.rbac.roles.WeaviateRolesClientAsync; +import io.weaviate.client6.v1.api.rbac.users.WeaviateUsersClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.VersionSupport; +import io.weaviate.client6.v1.internal.grpc.DefaultGrpcTransport; +import io.weaviate.client6.v1.internal.grpc.GrpcChannelOptions; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.rest.DefaultRestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransportOptions; + +public class WeaviateClientAsync implements AutoCloseable { + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + /** + * Client for {@code /schema} endpoints for managing Weaviate collections. + * See {@link WeaviateCollectionsClient#use} for populating and querying + * collections. + */ + public final WeaviateCollectionsClientAsync collections; + + /** Client for {@code /aliases} endpoints for managing collection aliases. */ + public final WeaviateAliasClientAsync alias; + + /** + * Client for {@code /authz/roles} endpoints for managing RBAC roles. + */ + public final WeaviateRolesClientAsync roles; + + /** + * Client for {@code /authz/groups} endpoints for managing RBAC groups. + */ + public final WeaviateGroupsClientAsync groups; + + /** + * Client for {@code /users} endpoints for managing DB / OIDC users. + */ + public final WeaviateUsersClientAsync users; + + /** Client for {@code /backups} endpoints for managing backups. */ + public final WeaviateBackupClientAsync backup; + + /** + * Client for {@code /nodes} and {@code /replication} endpoints + * for managing replication and sharding. + */ + public final WeaviateClusterClientAsync cluster; + + /** + * This constructor is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public WeaviateClientAsync(Config config) { + RestTransportOptions restOpt; + GrpcChannelOptions grpcOpt; + if (config.authentication() == null) { + restOpt = config.restTransportOptions(); + grpcOpt = config.grpcTransportOptions(); + } else { + TokenProvider tokenProvider; + try (final var noAuthRest = new DefaultRestTransport(config.restTransportOptions())) { + tokenProvider = config.authentication().getTokenProvider(noAuthRest); + } catch (Exception e) { + // Generally exceptions are caught in TokenProvider internals. + // This one may be thrown when noAuthRest transport is auto-closed. + throw new WeaviateOAuthException(e); + } + restOpt = config.restTransportOptions(tokenProvider); + grpcOpt = config.grpcTransportOptions(tokenProvider); + } + + // Initialize REST transport to a temporary variable to dispose of + // the associated resources in case we have to throw an exception. + // Assign to this.restTransport only once we're in the clear to + // avoid publishing the object before it's fully initialized. + var _restTransport = new DefaultRestTransport(restOpt.withTimeout( + new Timeout(restOpt.timeout().initSeconds()))); + boolean isLive = false; + InstanceMetadata meta = null; + try { + isLive = _restTransport.performRequest(null, IsLiveRequest._ENDPOINT); + meta = _restTransport.performRequest(null, InstanceMetadataRequest._ENDPOINT); + } catch (IOException e) { + throw new WeaviateConnectException(e); + } + + if (!isLive) { + var ex = new WeaviateConnectException("Weaviate not available at " + restOpt.baseUrl()); + try { + _restTransport.close(); + } catch (Exception e) { + ex.addSuppressed(e); + } + throw ex; + } + + if (!VersionSupport.isSupported(meta.version())) { + throw new WeaviateUnsupportedVersionException(meta.version()); + } + + if (meta.grpcMaxMessageSize() != null) { + grpcOpt = grpcOpt.withMaxMessageSize(meta.grpcMaxMessageSize()); + } + + this.restTransport = _restTransport; + this.grpcTransport = new DefaultGrpcTransport(grpcOpt); + this.alias = new WeaviateAliasClientAsync(restTransport); + this.backup = new WeaviateBackupClientAsync(restTransport); + this.roles = new WeaviateRolesClientAsync(restTransport); + this.groups = new WeaviateGroupsClientAsync(restTransport); + this.users = new WeaviateUsersClientAsync(restTransport); + this.cluster = new WeaviateClusterClientAsync(restTransport); + this.collections = new WeaviateCollectionsClientAsync(restTransport, grpcTransport); + } + + /** + * Connect to a local Weaviate instance. + * + *

+ * This call is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public static WeaviateClientAsync connectToLocal() { + return connectToLocal(ObjectBuilder.identity()); + } + + /** + * Connect to a local Weaviate instance. + * + *

+ * This call is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public static WeaviateClientAsync connectToLocal(Function> fn) { + return new WeaviateClientAsync(fn.apply(new Config.Local()).build()); + } + + /** + * Connect to a Weaviate Cloud instance. + * + *

+ * This call is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public static WeaviateClientAsync connectToWeaviateCloud(String httpHost, String apiKey) { + return connectToWeaviateCloud(httpHost, apiKey, ObjectBuilder.identity()); + } + + /** + * Connect to a Weaviate Cloud instance. + * + *

+ * This call is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public static WeaviateClientAsync connectToWeaviateCloud(String httpHost, String apiKey, + Function> fn) { + var config = new Config.WeaviateCloud(httpHost, Authentication.apiKey(apiKey)); + return new WeaviateClientAsync(fn.apply(config).build()); + } + + /** + * Connect to a Weaviate instance with custom configuration. + * + *

+ * This call is blocking if {@link Authentication} configured, + * as the client will need to do the initial token exchange. + */ + public static WeaviateClientAsync connectToCustom(Function> fn) { + return new WeaviateClientAsync(Config.of(fn)); + } + + /** Ping the server for a liveness check. */ + public CompletableFuture isLive() { + return this.restTransport.performRequestAsync(null, IsLiveRequest._ENDPOINT); + } + + /** Ping the server for a readiness check. */ + public CompletableFuture isReady() { + return this.restTransport.performRequestAsync(null, IsReadyRequest._ENDPOINT); + } + + /** Get deployement metadata for the target Weaviate instance. */ + public CompletableFuture meta() throws IOException { + return this.restTransport.performRequestAsync(null, InstanceMetadataRequest._ENDPOINT); + } + + /** + * Close {@link #restTransport} and {@link #grpcTransport} + * and release associated resources. + */ + @Override + public void close() throws Exception { + this.restTransport.close(); + this.grpcTransport.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateConnectException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateConnectException.java new file mode 100644 index 000000000..feda9c507 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateConnectException.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api; + +/** Exception thrown if the Weaviate instance appears to be offline. */ +public class WeaviateConnectException extends WeaviateException { + public WeaviateConnectException(String message) { + super(message); + } + + public WeaviateConnectException(String message, Throwable cause) { + super(message, cause); + } + + public WeaviateConnectException(Throwable cause) { + super(cause); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateException.java new file mode 100644 index 000000000..3ded81fa3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateException.java @@ -0,0 +1,38 @@ +package io.weaviate.client6.v1.api; + +/** + * WeaviateException is the base class for other library exceptions + * to provide an ergonomic way of handling any Weaviate-related exceptions. + * + *

+ * Some parts of the API may still throw other standard exceptions, like + * {@link java.io.IOException} or {@link java.lang.IllegalArgumentException}, + * which will not be wrapped into a WeaviateException. + * + *

+ * Usage: + * + *

{@code
+ *  var thigns = client.collections.use("Things");
+ *  try {
+ *    things.paginate(...)
+ *    things.query.bm25(...);
+ *    things.aggregate.overAll(...);
+ *  } catch (WeaviateException e) {
+ *    System.out.println(e);
+ *  }
+ * }
+ */ +public abstract class WeaviateException extends RuntimeException { + public WeaviateException(String message) { + super(message); + } + + public WeaviateException(Throwable cause) { + super(cause); + } + + public WeaviateException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateOAuthException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateOAuthException.java new file mode 100644 index 000000000..61d03d01d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateOAuthException.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api; + +/** + * Exception throws by the authentication layer if it encountered another + * exception at any point of obtaining the new token or rotating one. + */ +public class WeaviateOAuthException extends WeaviateException { + public WeaviateOAuthException(String message) { + super(message); + } + + public WeaviateOAuthException(String message, Throwable cause) { + super(message, cause); + } + + public WeaviateOAuthException(Throwable cause) { + super(cause); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateTransportException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateTransportException.java new file mode 100644 index 000000000..11ec7ece9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateTransportException.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api; + +/** Exception thrown by the internal transport layer. Usually not retryable. */ +public class WeaviateTransportException extends WeaviateException { + public WeaviateTransportException(String message) { + super(message); + } + + public WeaviateTransportException(String message, Throwable cause) { + super(message, cause); + } + + public WeaviateTransportException(Throwable cause) { + super(cause); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/WeaviateUnsupportedVersionException.java b/src/main/java/io/weaviate/client6/v1/api/WeaviateUnsupportedVersionException.java new file mode 100644 index 000000000..1e4e27580 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/WeaviateUnsupportedVersionException.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api; + +import io.weaviate.client6.v1.internal.VersionSupport; + +/** + * This exception is thrown when the client refuses to talk to an unsupported + * version of the server, see {@link VersionSupport#MINIMAL_SUPPORTED_VERSION}. + */ +public class WeaviateUnsupportedVersionException extends WeaviateException { + public WeaviateUnsupportedVersionException(String actual) { + this(VersionSupport.MINIMAL_SUPPORTED_VERSION.toString(), actual); + } + + public WeaviateUnsupportedVersionException(String minimal, String actual) { + super("Server version %s is not supported. Earliest supported version is %s.".formatted(actual, minimal)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/Alias.java b/src/main/java/io/weaviate/client6/v1/api/alias/Alias.java new file mode 100644 index 000000000..d19c68216 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/Alias.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.alias; + +import com.google.gson.annotations.SerializedName; + +public record Alias( + /** Original collection name. */ + @SerializedName("class") String collection, + /** Collection alias. */ + @SerializedName("alias") String alias) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/CreateAliasRequest.java b/src/main/java/io/weaviate/client6/v1/api/alias/CreateAliasRequest.java new file mode 100644 index 000000000..9b9dff27a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/CreateAliasRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateAliasRequest(Alias alias) { + public final static Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + __ -> "/aliases/", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.alias)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/DeleteAliasRequest.java b/src/main/java/io/weaviate/client6/v1/api/alias/DeleteAliasRequest.java new file mode 100644 index 000000000..c94101258 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/DeleteAliasRequest.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; + +public record DeleteAliasRequest(String alias) { + public final static Endpoint _ENDPOINT = BooleanEndpoint.noBody( + __ -> "DELETE", + request -> "/aliases/" + request.alias, + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/GetAliasRequest.java b/src/main/java/io/weaviate/client6/v1/api/alias/GetAliasRequest.java new file mode 100644 index 000000000..a3ad048b1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/GetAliasRequest.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.Collections; +import java.util.Optional; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record GetAliasRequest(String alias) { + public final static Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + __ -> "GET", + request -> "/aliases/" + request.alias, + __ -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, Alias.class)); + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasRequest.java b/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasRequest.java new file mode 100644 index 000000000..89940269f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasRequest.java @@ -0,0 +1,50 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListAliasRequest(String collection) { + public final static Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + __ -> "/aliases", + request -> request.collection != null + ? Map.of("class", request.collection) + : Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, ListAliasResponse.class).aliases()); + + /** Create default ListAliasRequest. */ + public static ListAliasRequest of() { + return of(ObjectBuilder.identity()); + } + + /** Create ListAliasRequest with optional parameters. */ + public static ListAliasRequest of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public ListAliasRequest(Builder builder) { + this(builder.collection); + } + + public static class Builder implements ObjectBuilder { + private String collection; + + /** Return only aliases which reference this collection. */ + public Builder collection(String collection) { + this.collection = collection; + return this; + } + + @Override + public ListAliasRequest build() { + return new ListAliasRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasResponse.java b/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasResponse.java new file mode 100644 index 000000000..f03a4f627 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/ListAliasResponse.java @@ -0,0 +1,8 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ListAliasResponse(@SerializedName("aliases") List aliases) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/UpdateAliasRequest.java b/src/main/java/io/weaviate/client6/v1/api/alias/UpdateAliasRequest.java new file mode 100644 index 000000000..060db8def --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/UpdateAliasRequest.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.Collections; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record UpdateAliasRequest(String alias, String newTargetCollection) { + public final static Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "PUT", + request -> "/aliases/" + request.alias, + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.toRequestBody())); + + private RequestBody toRequestBody() { + return new RequestBody(); + } + + private class RequestBody { + @SerializedName("class") + private final String collection = UpdateAliasRequest.this.newTargetCollection; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClient.java b/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClient.java new file mode 100644 index 000000000..57c018828 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClient.java @@ -0,0 +1,127 @@ +package io.weaviate.client6.v1.api.alias; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateAliasClient { + private final RestTransport restTransport; + + public WeaviateAliasClient(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Create a new collection alias. + * + * @param collection Original collection name. + * @param alias Collection alias. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(String collection, String alias) throws IOException { + create(new Alias(collection, alias)); + } + + /** + * Create a new collection alias. + * + * @param alias Alias object. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(Alias alias) throws IOException { + this.restTransport.performRequest(new CreateAliasRequest(alias), CreateAliasRequest._ENDPOINT); + } + + /** + * List all collection aliases defined in the cluster. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list() throws IOException { + return list(ListAliasRequest.of()); + } + + /** + * List all collection aliases defined in the cluster. + * + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * @return A list of aliases. + */ + public List list(Function> fn) throws IOException { + return list(ListAliasRequest.of(fn)); + } + + private List list(ListAliasRequest request) throws IOException { + return this.restTransport.performRequest(request, ListAliasRequest._ENDPOINT); + } + + /** + * Get alias by name. + * + * @param alias Collection alias. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * @return Alias if one exists and empty {@code Optional} otherwise. + */ + public Optional get(String alias) throws IOException { + return this.restTransport.performRequest(new GetAliasRequest(alias), GetAliasRequest._ENDPOINT); + } + + /** + * Change which collection this alias references. + * + * @param alias Collection alias. + * @param newTargetCollection Collection name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void update(String alias, String newTargetCollection) throws IOException { + this.restTransport.performRequest(new UpdateAliasRequest(alias, newTargetCollection), + UpdateAliasRequest._ENDPOINT); + } + + /** + * Delete an alias. The previously aliased collection is not affected. + * + * @param alias Collection alias. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * + * @return {@code true} if the alias was deleted, {@code false} if there was no + * alias to delete. + */ + public boolean delete(String alias) throws IOException { + return this.restTransport.performRequest(new DeleteAliasRequest(alias), DeleteAliasRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClientAsync.java new file mode 100644 index 000000000..00e59729d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/alias/WeaviateAliasClientAsync.java @@ -0,0 +1,100 @@ +package io.weaviate.client6.v1.api.alias; + +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +/** Async client for {@code /aliases} endpoints. */ +public class WeaviateAliasClientAsync { + private final RestTransport restTransport; + + public WeaviateAliasClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Create a new collection alias. + * + * @param collection Original collection name. + * @param alias Collection alias. + * + * @return A future holding the server's response. + */ + public CompletableFuture create(String collection, String alias) { + return create(new Alias(collection, alias)); + } + + /** + * Create a new collection alias. + * + * @param alias Alias object. + * + * @return A future holding the server's response. + */ + public CompletableFuture create(Alias alias) { + return this.restTransport.performRequestAsync(new CreateAliasRequest(alias), CreateAliasRequest._ENDPOINT); + } + + /** + * List all collection aliases defined in the cluster. + * + * @return A future holding the server's response. + */ + public CompletableFuture> list() { + return list(ListAliasRequest.of()); + } + + /** + * List all collection aliases defined in the cluster. + * + * @param fn Lambda expression for optional parameters. + * + * @return A future holding the server's response. + */ + public CompletableFuture> list(Function> fn) { + return list(ListAliasRequest.of(fn)); + } + + private CompletableFuture> list(ListAliasRequest request) { + return this.restTransport.performRequestAsync(request, ListAliasRequest._ENDPOINT); + } + + /** + * Get alias by name. + * + * @param alias Collection alias. + * + * @return A future holding the server's response. + */ + public CompletableFuture> get(String alias) { + return this.restTransport.performRequestAsync(new GetAliasRequest(alias), GetAliasRequest._ENDPOINT); + } + + /** + * Change which collection this alias references. + * + * @param alias Collection alias. + * @param newTargetCollection Collection name. + * + * @return A future holding the server's response. + */ + public CompletableFuture update(String alias, String newTargetCollection) { + return this.restTransport.performRequestAsync(new UpdateAliasRequest(alias, newTargetCollection), + UpdateAliasRequest._ENDPOINT); + } + + /** + * Delete an alias. The previously aliased collection is not affected. + * + * @param alias Collection alias. + * + * @return A future holding the server's response. + */ + public CompletableFuture delete(String alias) { + return this.restTransport.performRequestAsync(new DeleteAliasRequest(alias), DeleteAliasRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/Backup.java b/src/main/java/io/weaviate/client6/v1/api/backup/Backup.java new file mode 100644 index 000000000..9fa1c1025 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/Backup.java @@ -0,0 +1,226 @@ +package io.weaviate.client6.v1.api.backup; + +import java.io.IOException; +import java.time.OffsetDateTime; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeoutException; +import java.util.function.Function; +import java.util.function.Supplier; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.WeaviateClient; +import io.weaviate.client6.v1.api.WeaviateClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Backup( + /** Backup ID. */ + @SerializedName("id") String id, + /** Path to backup in the backend storage. */ + @SerializedName("path") String path, + /** Backup storage backend. */ + @SerializedName("backend") String backend, + /** Collections included in the backup. */ + @SerializedName("classes") List includesCollections, + /** Backup creation / restoration status. */ + @SerializedName("status") BackupStatus status, + /** Backup creation / restoration error. */ + @SerializedName("error") String error, + /** Time at which the backup creation. */ + @SerializedName("startedAt") OffsetDateTime startedAt, + /** Time at which the backup was completed, successfully or otherwise. */ + @SerializedName("completedAt") OffsetDateTime completedAt, + /** Backup size in GiB. */ + @SerializedName("size") Float sizeGiB, + /** + * This value indicates if a backup is being created or restored from. + * For operations like LIST this value is null. + */ + // We set a bogus SerializedName to make sure we do not pick up this + // value from the JSON by accident, but always set it ourselves. + @SerializedName("__operation__") Operation operation) { + + /** Set operation associated with this backup. */ + Backup withOperation(Operation operation) { + return new Backup( + id, + path, + backend, + includesCollections, + status, + error, + startedAt, + completedAt, + sizeGiB, + operation); + } + + public enum Operation { + CREATE, RESTORE; + } + + /** + * Block until the backup has been created / restored successfully. + * + * @param client Weaviate client. Make sure {@link WeaviateClient#close} + * is NOT called before this method returns. + * @throws IllegalStateException if {@link #operation} is not set (null). + * @throws TimeoutException in case the wait times out without reaching + * BackupStatus.SUCCESS. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup waitForCompletion(WeaviateClient client) throws IOException, TimeoutException { + return waitForStatus(client, BackupStatus.SUCCESS); + } + + /** + * Block until the backup has been created / restored successfully. + * + * @param client Weaviate client. Make sure {@link WeaviateClient#close} + * is NOT called before this method returns. + * @param fn Lambda expression for optional parameters. + * @throws IllegalStateException if {@link #operation} is not set (null). + * @throws TimeoutException in case the wait times out without reaching + * BackupStatus.SUCCESS. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup waitForCompletion(WeaviateClient client, Function> fn) + throws IOException, TimeoutException { + return waitForStatus(client, BackupStatus.SUCCESS, fn); + } + + /** + * Block until the backup operation reaches a certain status. + * + * @param client Weaviate client. Make sure {@link WeaviateClient#close} + * is NOT called before this method returns. + * @param status Target status. + * @throws IllegalStateException if {@link #operation} is not set (null). + * @throws TimeoutException in case the wait times out without reaching + * the target status. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup waitForStatus(WeaviateClient client, BackupStatus status) throws IOException, TimeoutException { + return waitForStatus(client, status, ObjectBuilder.identity()); + } + + /** + * Block until the backup operation reaches a certain status. + * + * @param client Weaviate client. Make sure {@link WeaviateClient#close} + * is NOT called before this method returns. + * @param status Target status. + * @param fn Lambda expression for optional parameters. + * @throws IllegalStateException if {@link #operation} is not set (null). + * @throws TimeoutException in case the wait times out without reaching + * the target status. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup waitForStatus(WeaviateClient client, BackupStatus status, + Function> fn) throws IOException, TimeoutException { + if (operation == null) { + throw new IllegalStateException("backup.operation is null"); + } + + final var options = WaitOptions.of(fn); + final Callable> poll = operation == Operation.CREATE + ? () -> client.backup.getCreateStatus(id, backend) + : () -> client.backup.getRestoreStatus(id, backend); + return new Waiter(this, options).waitForStatus(status, poll); + } + + /** + * Cancel backup creation. + * + *

+ * This method cannot be called to cancel backup restore. + * + * @param client Weaviate client. Make sure {@link WeaviateClient#close} + * is NOT called before this method returns. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void cancel(WeaviateClient client) throws IOException { + client.backup.cancel(id(), backend()); + } + + /** + * Poll until backup's been created / restored successfully. + * + * @param client Weaviate client. Make sure {@link WeaviateClientAsync#close} + * is NOT called before this method returns. + * @throws IllegalStateException if {@link #operation} is not set (null). + */ + public CompletableFuture waitForCompletion(WeaviateClientAsync client) { + return waitForStatus(client, BackupStatus.SUCCESS); + } + + /** + * Poll until backup's been created / restored successfully. + * + * @param client Weaviate client. Make sure {@link WeaviateClientAsync#close} + * is NOT called before this method returns. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture waitForCompletion(WeaviateClientAsync client, + Function> fn) { + return waitForStatus(client, BackupStatus.SUCCESS, fn); + } + + /** + * Poll until backup reaches a certain status or the wait times out. + * + * @param client Weaviate client. Make sure {@link WeaviateClientAsync#close} + * is NOT called before this method returns. + * @param status Target status. + */ + public CompletableFuture waitForStatus(WeaviateClientAsync client, BackupStatus status) { + return waitForStatus(client, status, ObjectBuilder.identity()); + } + + /** + * Poll until backup reaches a certain status or the wait times out. + * + * @param client Weaviate client. Make sure {@link WeaviateClientAsync#close} + * is NOT called before this method returns. + * @param status Target status. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture waitForStatus(WeaviateClientAsync client, BackupStatus status, + Function> fn) { + if (operation == null) { + throw new IllegalStateException("backup.operation is null"); + } + + final var options = WaitOptions.of(fn); + final Supplier>> poll = operation == Operation.CREATE + ? () -> client.backup.getCreateStatus(id, backend) + : () -> client.backup.getRestoreStatus(id, backend); + return new Waiter(this, options).waitForStatusAsync(status, poll); + } + + /** + * Cancel backup creation. + * + *

+ * This method cannot be called to cancel backup restore. + * + * @param client Weaviate client. Make sure {@link WeaviateClientAsync#close} + * is NOT called before this method returns. + */ + public CompletableFuture cancel(WeaviateClientAsync client) { + return client.backup.cancel(id(), backend()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/BackupStatus.java b/src/main/java/io/weaviate/client6/v1/api/backup/BackupStatus.java new file mode 100644 index 000000000..74d4ff30b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/BackupStatus.java @@ -0,0 +1,24 @@ +package io.weaviate.client6.v1.api.backup; + +import com.google.gson.annotations.SerializedName; + +public enum BackupStatus { + /** Backup creation / restoration has begun. */ + @SerializedName("STARTED") + STARTED, + /** Backup in progress, data is being transferred. */ + @SerializedName("TRANSFERRING") + TRANSFERRING, + /** Backup creation / restoration completed successfully. */ + @SerializedName("SUCCESS") + SUCCESS, + /** Backup creation / restoration failed. */ + @SerializedName("FAILED") + FAILED, + /** + * Backup creation canceled. + * This status is never returned for backup restorations. + */ + @SerializedName("CANCELED") + CANCELED; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/CancelBackupRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/CancelBackupRequest.java new file mode 100644 index 000000000..9c311f9c9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/CancelBackupRequest.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CancelBackupRequest(String backupId, String backend) { + + public static Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "DELETE", + request -> "/backups/" + request.backend + "/" + request.backupId, + request -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/CompressionLevel.java b/src/main/java/io/weaviate/client6/v1/api/backup/CompressionLevel.java new file mode 100644 index 000000000..b5951ebe0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/CompressionLevel.java @@ -0,0 +1,27 @@ +package io.weaviate.client6.v1.api.backup; + +import com.google.gson.annotations.SerializedName; + +public enum CompressionLevel { + /** Use default compression algorithm (gzip). */ + @SerializedName("DefaultCompression") + DEFAULT, + /** Use compression algorithm that prioritizes speed. */ + @SerializedName("BestSpeed") + BEST_SPEED, + /** Use compression algorithm that prioritizes compression quality. */ + @SerializedName("BestCompression") + BEST_COMPRESSION, + /** Use ZSTD compression algorithm at default (balanced) settings. */ + @SerializedName("ZstdDefaultCompression") + ZSTD_DEFAULT, + /** Use ZSTD compression algorithm and prioritize speed. */ + @SerializedName("ZstdBestSpeed") + ZSTD_BEST_SPEED, + /** Use ZSTD compression algorithm and prioritize compression quality. */ + @SerializedName("ZstdBestCompression") + ZSTD_BEST_COMPRESSION, + /** Do not use compression. */ + @SerializedName("NoCompression") + NO_COMPRESSION; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/CreateBackupRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/CreateBackupRequest.java new file mode 100644 index 000000000..e7c15d02e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/CreateBackupRequest.java @@ -0,0 +1,131 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateBackupRequest(BackupCreate body, String backend) { + + public static Endpoint _ENDPOINT = new SimpleEndpoint<>( + request -> "POST", + request -> "/backups/" + request.backend, + request -> Collections.emptyMap(), + request -> JSON.serialize(request.body), + (statusCode, response) -> JSON.deserialize(response, Backup.class)); + + public static record BackupCreate( + @SerializedName("id") String id, + @SerializedName("include") List includeCollections, + @SerializedName("exclude") List excludeCollections, + @SerializedName("config") Config config) { + + private static record Config( + @SerializedName("CPUPercentage") Integer cpuPercentage, + @SerializedName("CompressionLevel") CompressionLevel compressionLevel, + @SerializedName("Bucket") String bucket, + @SerializedName("Path") String path) { + } + + public static BackupCreate of(String backupId) { + return of(backupId, ObjectBuilder.identity()); + } + + public static BackupCreate of(String backupId, Function> fn) { + return fn.apply(new Builder(backupId)).build(); + } + + public BackupCreate(Builder builder) { + this( + builder.backupId, + builder.includeCollections, + builder.excludeCollections, + new Config( + builder.cpuPercentage, + builder.compressionLevel, + builder.bucket, + builder.path)); + } + + public static class Builder implements ObjectBuilder { + private final String backupId; + + private Integer cpuPercentage; + private CompressionLevel compressionLevel; + private String bucket; + private String path; + private final List includeCollections = new ArrayList<>(); + private final List excludeCollections = new ArrayList<>(); + + public Builder(String backupId) { + this.backupId = backupId; + } + + /** Collection that should be included in the backup. */ + public Builder includeCollections(String... includeCollections) { + return includeCollections(Arrays.asList(includeCollections)); + } + + /** Collection that should be included in the backup. */ + public Builder includeCollections(List includeCollections) { + this.includeCollections.addAll(includeCollections); + return this; + } + + /** Collection that should be excluded from the backup. */ + public Builder excludeCollections(String... excludeCollections) { + return excludeCollections(Arrays.asList(excludeCollections)); + } + + /** Collection that should be excluded from the backup. */ + public Builder excludeCollections(List excludeCollections) { + this.excludeCollections.addAll(excludeCollections); + return this; + } + + /** + * Set the desired CPU core utilization. + * + * @param cpuPercentage Percent value of the target CPU utilization (1% to 80%). + */ + public Builder cpuPercentage(int cpuPercentage) { + this.cpuPercentage = cpuPercentage; + return this; + } + + /** Adjust the parameters of the selected compression algorithm. */ + public Builder compressionLevel(CompressionLevel compressionLevel) { + this.compressionLevel = compressionLevel; + return this; + } + + /** + * Set the bucket where backups are stored. + * Applicable for cloud storage backends. + */ + public Builder bucket(String bucket) { + this.bucket = bucket; + return this; + } + + /** Override default backup location. */ + public Builder path(String path) { + this.path = path; + return this; + } + + @Override + public BackupCreate build() { + return new BackupCreate(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/GetCreateStatusRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/GetCreateStatusRequest.java new file mode 100644 index 000000000..52d23d19f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/GetCreateStatusRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.Collections; +import java.util.Optional; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record GetCreateStatusRequest(String backupId, String backend) { + public static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + request -> "GET", + request -> "/backups/" + request.backend + "/" + request.backupId, + request -> Collections.emptyMap(), + Backup.class); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/GetRestoreStatusRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/GetRestoreStatusRequest.java new file mode 100644 index 000000000..f4430b80d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/GetRestoreStatusRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.Collections; +import java.util.Optional; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record GetRestoreStatusRequest(String backupId, String backend) { + public static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + request -> "GET", + request -> "/backups/" + request.backend + "/" + request.backupId + "/restore", + request -> Collections.emptyMap(), + Backup.class); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/ListBackupsRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/ListBackupsRequest.java new file mode 100644 index 000000000..19d8e406d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/ListBackupsRequest.java @@ -0,0 +1,61 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.HashMap; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListBackupsRequest(String backend, boolean startingTimeAsc) { + + @SuppressWarnings("unchecked") + public static Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + request -> "GET", + request -> "/backups/" + request.backend, + request -> new HashMap<>() { + { + if (request.startingTimeAsc) { + put("order", "asc"); + } + } + }, + (statusCode, response) -> (List) JSON.deserialize( + response, TypeToken.getParameterized(List.class, Backup.class))); + + public static ListBackupsRequest of(String backend) { + return of(backend, ObjectBuilder.identity()); + } + + public static ListBackupsRequest of(String backend, Function> fn) { + return fn.apply(new Builder(backend)).build(); + } + + public ListBackupsRequest(Builder builder) { + this(builder.backend, builder.startingTimeAsc); + } + + public static class Builder implements ObjectBuilder { + private final String backend; + private boolean startingTimeAsc = false; + + public Builder(String backend) { + this.backend = backend; + } + + /** Sort the backups by their starting time, oldest to newest. */ + public Builder sortByStartingTimeAsc(boolean enable) { + this.startingTimeAsc = enable; + return this; + } + + @Override + public ListBackupsRequest build() { + return new ListBackupsRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/RbacRestoreOption.java b/src/main/java/io/weaviate/client6/v1/api/backup/RbacRestoreOption.java new file mode 100644 index 000000000..b2ba14d68 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/RbacRestoreOption.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api.backup; + +import com.google.gson.annotations.SerializedName; + +/** Controls which RBAC objects (users, roles) get restored. */ +public enum RbacRestoreOption { + /** Do not restore any objects. */ + @SerializedName("noRestore") + NONE, + /** Restore all objects. */ + @SerializedName("all") + ALL; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/RestoreBackupRequest.java b/src/main/java/io/weaviate/client6/v1/api/backup/RestoreBackupRequest.java new file mode 100644 index 000000000..bc017d8ea --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/RestoreBackupRequest.java @@ -0,0 +1,145 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record RestoreBackupRequest(String backupId, String backend, BackupRestore body) { + + public static Endpoint _ENDPOINT = new SimpleEndpoint<>( + request -> "POST", + request -> "/backups/" + request.backend + "/" + request.backupId + "/restore", + request -> Collections.emptyMap(), + request -> JSON.serialize(request.body), + (statusCode, response) -> JSON.deserialize(response, Backup.class)); + + public record BackupRestore( + @SerializedName("include") List includeCollections, + @SerializedName("exclude") List excludeCollections, + @SerializedName("overwriteAlias") Boolean overwriteAlias, + @SerializedName("config") Config config) { + + public record Config( + @SerializedName("CPUPercentage") Integer cpuPercentage, + @SerializedName("Bucket") String bucket, + @SerializedName("Path") String path, + @SerializedName("usersOptions") RbacRestoreOption restoreUsers, + @SerializedName("rolesOptions") RbacRestoreOption restoreRoles) { + } + + public static BackupRestore of() { + return of(ObjectBuilder.identity()); + } + + public static BackupRestore of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public BackupRestore(Builder builder) { + this( + builder.includeCollections, + builder.excludeCollections, + builder.overwriteAlias, + new Config( + builder.cpuPercentage, + builder.bucket, + builder.path, + builder.restoreUsers, + builder.restoreRoles)); + + } + + public static class Builder implements ObjectBuilder { + private Integer cpuPercentage; + private String bucket; + private String path; + private Boolean overwriteAlias; + private RbacRestoreOption restoreUsers; + private RbacRestoreOption restoreRoles; + private final List includeCollections = new ArrayList<>(); + private final List excludeCollections = new ArrayList<>(); + + /** Collection that should be restored. */ + public Builder includeCollections(String... includeCollections) { + return includeCollections(Arrays.asList(includeCollections)); + } + + /** Collection that should be restored. */ + public Builder includeCollections(List includeCollections) { + this.includeCollections.addAll(includeCollections); + return this; + } + + /** Collection that should be not be restored. */ + public Builder excludeCollections(String... excludeCollections) { + return excludeCollections(Arrays.asList(excludeCollections)); + } + + /** Collection that should be not be restored. */ + public Builder excludeCollections(List excludeCollections) { + this.excludeCollections.addAll(excludeCollections); + return this; + } + + /** + * Set the desired CPU core utilization. + * + * @param cpuPercentage Percent value of the target CPU utilization (1% to 80%). + */ + public Builder cpuPercentage(int cpuPercentage) { + this.cpuPercentage = cpuPercentage; + return this; + } + + /** + * Set the bucket where backups are stored. + * Applicable for cloud storage backends. + */ + public Builder bucket(String bucket) { + this.bucket = bucket; + return this; + } + + /** Override default backup location. */ + public Builder path(String path) { + this.path = path; + return this; + } + + /** + * Allow restored collection aliases to overwrite existing ones + * in case of conflict. + */ + public Builder overwriteAlias(boolean overwriteAlias) { + this.overwriteAlias = overwriteAlias; + return this; + } + + /** Control which RBAC users should be restored. */ + public Builder restoreUsers(RbacRestoreOption restoreUsers) { + this.restoreUsers = restoreUsers; + return this; + } + + /** Control which RBAC roles should be restored. */ + public Builder restoreRoles(RbacRestoreOption restoreRoles) { + this.restoreRoles = restoreRoles; + return this; + } + + @Override + public BackupRestore build() { + return new BackupRestore(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/WaitOptions.java b/src/main/java/io/weaviate/client6/v1/api/backup/WaitOptions.java new file mode 100644 index 000000000..1044bc6e2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/WaitOptions.java @@ -0,0 +1,64 @@ +package io.weaviate.client6.v1.api.backup; + +import java.time.Duration; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record WaitOptions(long interval, long timeout) { + private static final long DEFAULT_INTERVAL_MILLIS = 1_000; + private static final long DEFAULT_TIMEOUT_MILLIS = 3600_000; + + public static WaitOptions of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public WaitOptions(Builder builder) { + this(builder.interval, builder.timeout); + } + + public static class Builder implements ObjectBuilder { + private long interval = DEFAULT_INTERVAL_MILLIS; + private long timeout = DEFAULT_TIMEOUT_MILLIS; + + /** Set polling interval. Defaults to 1s. */ + public Builder interval(Duration duration) { + return interval(duration.toMillis()); + } + + /** + * Set polling interval. Defaults to 1s. + * + * @param intervalMillis Polling interval in milliseconds. Minimum 1ms. + */ + public Builder interval(long intervalMillis) { + this.interval = Math.max(intervalMillis, 1); + return this; + } + + /** + * Set wait timeout. Defaults to 1s. + * + * @param duration Wait timeout duration. + */ + public Builder timeout(Duration duration) { + return timeout(duration.toMillis()); + } + + /** + * Set wait timeout. Set this to a negative value + * for the wait to expire immediately. + * + * @param timeoutMillis Wait timeout in milliseconds. + */ + public Builder timeout(long timeoutMillis) { + this.timeout = timeoutMillis; + return this; + } + + @Override + public WaitOptions build() { + return new WaitOptions(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/Waiter.java b/src/main/java/io/weaviate/client6/v1/api/backup/Waiter.java new file mode 100644 index 000000000..82528b735 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/Waiter.java @@ -0,0 +1,104 @@ +package io.weaviate.client6.v1.api.backup; + +import java.io.IOException; +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.function.Supplier; + +final class Waiter { + + private final Backup backup; + private final WaitOptions wait; + + Waiter(final Backup backup, WaitOptions wait) { + this.backup = backup; + this.wait = wait; + } + + Backup waitForStatus(final BackupStatus wantStatus, Callable> poll) + throws IOException, TimeoutException { + if (backup.error() != null) { + throw new RuntimeException(backup.error()); + } + + if (backup.status() == wantStatus) { + return backup; + } + + final Instant deadline = Instant.now().plusMillis(wait.timeout()); + Backup latest = backup; + while (!Thread.interrupted()) { + if (Instant.now().isAfter(deadline)) { + throw new TimeoutException("timed out after %s, latest status %s".formatted( + Duration.ofMillis(wait.timeout()).toSeconds(), latest.status())); + } + + try { + var current = poll.call().orElseThrow(); + latest = current; + } catch (Exception e) { + throw new RuntimeException(e); + } + + if (latest.status() == wantStatus) { + return latest; + } else if (isComplete(latest)) { + throw new IllegalStateException("completed with status=%s without reaching %s" + .formatted(latest.status(), wantStatus)); + } + + try { + Thread.sleep(wait.interval()); + } catch (InterruptedException e) { + // TODO: the interrupted state will be cleared on the next while() check + // and then we will simply return the latest state. An absence of an exception + // might be misleading here. What should we do? + Thread.currentThread().interrupt(); + } + } + return latest; + } + + CompletableFuture waitForStatusAsync( + final BackupStatus wantStatus, + Supplier>> poll) { + if (backup.status() == wantStatus) { + return CompletableFuture.completedFuture(backup); + } + final Instant deadline = Instant.now().plusMillis(wait.timeout()); + return poll.get().thenCompose(latest -> _waitForStatusAsync(wantStatus, latest.orElseThrow(), poll, deadline)); + } + + CompletableFuture _waitForStatusAsync( + final BackupStatus wantStatus, + final Backup current, + Supplier>> poll, + final Instant deadline) { + + if (current.status() == wantStatus) { + return CompletableFuture.completedFuture(current); + } + + if (Instant.now().isAfter(deadline)) { + var e = new TimeoutException("timed out after %s, latest status %s".formatted( + Duration.ofMillis(wait.timeout()).toSeconds(), current.status())); + throw new CompletionException(e); + } + + return poll.get().thenComposeAsync( + latest -> _waitForStatusAsync(wantStatus, latest.orElseThrow(), poll, deadline), + CompletableFuture.delayedExecutor(wait.interval(), TimeUnit.MILLISECONDS)); + } + + private boolean isComplete(final Backup backup) { + return backup.status() == BackupStatus.SUCCESS + || backup.status() == BackupStatus.FAILED + || backup.status() == BackupStatus.CANCELED; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClient.java b/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClient.java new file mode 100644 index 000000000..90bf70b8a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClient.java @@ -0,0 +1,196 @@ +package io.weaviate.client6.v1.api.backup; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateBackupClient { + private final RestTransport restTransport; + + public WeaviateBackupClient(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Start a new backup process. + * + * @param backupId Backup ID. Must be unique for the backend. + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup create(String backupId, String backend) throws IOException { + return create(new CreateBackupRequest(CreateBackupRequest.BackupCreate.of(backupId), backend)); + } + + /** + * Start a new backup process. + * + * @param backupId Backup ID. Must be unique for the backend. + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup create(String backupId, String backend, + Function> fn) + throws IOException { + return create(new CreateBackupRequest(CreateBackupRequest.BackupCreate.of(backupId, fn), backend)); + } + + /** + * Start a new backup process. + * + * @param request Create backup request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup create(CreateBackupRequest request) throws IOException { + return this.restTransport.performRequest(request, CreateBackupRequest._ENDPOINT) + .withOperation(Backup.Operation.CREATE); + } + + /** + * Get backup create status. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional getCreateStatus(String backupId, String backend) throws IOException { + return this.restTransport.performRequest( + new GetCreateStatusRequest(backupId, backend), GetCreateStatusRequest._ENDPOINT) + .map(b -> b.withOperation(Backup.Operation.CREATE)); + } + + /** + * Start backup restore process. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup restore(String backupId, String backend) throws IOException { + return restore(new RestoreBackupRequest(backupId, backend, RestoreBackupRequest.BackupRestore.of())); + } + + /** + * Start backup restore process. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup restore(String backupId, String backend, + Function> fn) + throws IOException { + return restore(new RestoreBackupRequest(backupId, backend, RestoreBackupRequest.BackupRestore.of(fn))); + } + + /** + * Start backup restore process. + * + * @param request Restore backup request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Backup restore(RestoreBackupRequest request) throws IOException { + return this.restTransport.performRequest(request, RestoreBackupRequest._ENDPOINT) + .withOperation(Backup.Operation.RESTORE); + } + + /** + * Get backup restore status. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional getRestoreStatus(String backupId, String backend) throws IOException { + return this.restTransport + .performRequest(new GetRestoreStatusRequest(backupId, backend), GetRestoreStatusRequest._ENDPOINT) + .map(b -> b.withOperation(Backup.Operation.RESTORE)); + } + + /** + * List backups in the backend storage. + * + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list(String backend) throws IOException { + return this.restTransport.performRequest(ListBackupsRequest.of(backend), ListBackupsRequest._ENDPOINT); + } + + /** + * List backups in the backend storage. + * + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list(String backend, Function> fn) + throws IOException { + return this.restTransport.performRequest(ListBackupsRequest.of(backend, fn), ListBackupsRequest._ENDPOINT); + } + + /** + * Cancel in-progress backup. + * + *

+ * This method cannot be called cancel backup restore. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void cancel(String backupId, String backend) throws IOException { + this.restTransport.performRequest(new CancelBackupRequest(backupId, backend), CancelBackupRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClientAsync.java new file mode 100644 index 000000000..e0eab8863 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/backup/WeaviateBackupClientAsync.java @@ -0,0 +1,139 @@ +package io.weaviate.client6.v1.api.backup; + +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateBackupClientAsync { + private final RestTransport restTransport; + + public WeaviateBackupClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Start a new backup process. + * + * @param backupId Backup ID. Must be unique for the backend. + * @param backend Backup storage backend. + */ + public CompletableFuture create(String backupId, String backend) { + return create(new CreateBackupRequest(CreateBackupRequest.BackupCreate.of(backupId), backend)); + } + + /** + * Start a new backup process. + * + * @param backupId Backup ID. Must be unique for the backend. + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture create(String backupId, String backend, + Function> fn) { + return create(new CreateBackupRequest(CreateBackupRequest.BackupCreate.of(backupId, fn), backend)); + } + + /** + * Start a new backup process. + * + * @param request Create backup request. + */ + public CompletableFuture create(CreateBackupRequest request) { + return this.restTransport.performRequestAsync(request, CreateBackupRequest._ENDPOINT) + .thenApply(bak -> bak.withOperation(Backup.Operation.CREATE)); + } + + /** + * Get backup create status. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + */ + public CompletableFuture> getCreateStatus(String backupId, String backend) { + return this.restTransport.performRequestAsync( + new GetCreateStatusRequest(backupId, backend), GetCreateStatusRequest._ENDPOINT) + .thenApply(bak -> bak.map(_bak -> _bak.withOperation(Backup.Operation.CREATE))); + } + + /** + * Start backup restore process. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + */ + public CompletableFuture restore(String backupId, String backend) { + return restore(new RestoreBackupRequest(backupId, backend, RestoreBackupRequest.BackupRestore.of())); + } + + /** + * Start backup restore process. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture restore(String backupId, String backend, + Function> fn) { + return restore(new RestoreBackupRequest(backupId, backend, RestoreBackupRequest.BackupRestore.of(fn))); + } + + /** + * Start backup restore process. + * + * @param request Restore backup request. + */ + public CompletableFuture restore(RestoreBackupRequest request) { + return this.restTransport.performRequestAsync(request, RestoreBackupRequest._ENDPOINT) + .thenApply(bak -> bak.withOperation(Backup.Operation.RESTORE)); + } + + /** + * Get backup restore status. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + */ + public CompletableFuture> getRestoreStatus(String backupId, String backend) { + return this.restTransport + .performRequestAsync(new GetRestoreStatusRequest(backupId, backend), GetRestoreStatusRequest._ENDPOINT) + .thenApply(bak -> bak.map(_bak -> _bak.withOperation(Backup.Operation.RESTORE))); + } + + /** + * List backups in the backend storage. + * + * @param backend Backup storage backend. + */ + public CompletableFuture> list(String backend) { + return this.restTransport.performRequestAsync(ListBackupsRequest.of(backend), ListBackupsRequest._ENDPOINT); + } + + /** + * List backups in the backend storage. + * + * @param backend Backup storage backend. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> list(String backend, + Function> fn) { + return this.restTransport.performRequestAsync(ListBackupsRequest.of(backend, fn), ListBackupsRequest._ENDPOINT); + } + + /** + * Cancel in-progress backup. + * + *

+ * This method cannot be called cancel backup restore. + * + * @param backupId Backup ID. + * @param backend Backup storage backend. + */ + public CompletableFuture cancel(String backupId, String backend) { + return this.restTransport.performRequestAsync(new CancelBackupRequest(backupId, backend), + CancelBackupRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/AsyncReplicationStatus.java b/src/main/java/io/weaviate/client6/v1/api/cluster/AsyncReplicationStatus.java new file mode 100644 index 000000000..9eac8f644 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/AsyncReplicationStatus.java @@ -0,0 +1,9 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public record AsyncReplicationStatus( + @SerializedName("objectsPropagated") long objectsPropagated, + @SerializedName("startDiffTimeUnixMillis") long startDiffTimeUnixMillis, + @SerializedName("targetNode") String targetNode) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/CollectionStats.java b/src/main/java/io/weaviate/client6/v1/api/cluster/CollectionStats.java new file mode 100644 index 000000000..7c74e5070 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/CollectionStats.java @@ -0,0 +1,8 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public record CollectionStats( + @SerializedName("shardCount") int shardCount, + @SerializedName("objectCount") long objectCount) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesRequest.java new file mode 100644 index 000000000..93583d7bb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesRequest.java @@ -0,0 +1,64 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.HashMap; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListNodesRequest(String collection, String shard, NodeVerbosity verbosity) { + + static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/nodes" + (request.collection != null + ? "/" + request.collection + : ""), + request -> new HashMap<>() { // HashMap permits null values. + { + put("shardName", request.shard); + put("output", request.verbosity); + } + }, + (statusCode, response) -> JSON.deserialize(response, ListNodesResponse.class).nodes()); + + public static ListNodesRequest of() { + return of(ObjectBuilder.identity()); + } + + public static ListNodesRequest of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public ListNodesRequest(Builder builder) { + this(builder.collection, builder.shard, builder.verbosity); + } + + public static class Builder implements ObjectBuilder { + private String collection; + private String shard; + private NodeVerbosity verbosity; + + public Builder collection(String collection) { + this.collection = collection; + return this; + } + + public Builder shard(String shard) { + this.shard = shard; + return this; + } + + public Builder verbosity(NodeVerbosity verbosity) { + this.verbosity = verbosity; + return this; + } + + @Override + public ListNodesRequest build() { + return new ListNodesRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesResponse.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesResponse.java new file mode 100644 index 000000000..775a8f492 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ListNodesResponse.java @@ -0,0 +1,6 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.List; + +public record ListNodesResponse(List nodes) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsRequest.java new file mode 100644 index 000000000..604a247fe --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsRequest.java @@ -0,0 +1,55 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.HashMap; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record ListShardsRequest(String collection, String shard) { + + static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + __ -> "GET", + __ -> "/replication/sharding-state", + request -> new HashMap<>() { // `shard` can be null, HashMap permits null values. + { + put("collection", request.collection); + put("shard", request.shard); + } + }, + (statusCode, response) -> JSON.deserialize(response, ListShardsResponse.class).shardingState()); + + public static ListShardsRequest of(String collection) { + return of(collection, ObjectBuilder.identity()); + } + + public static ListShardsRequest of(String collection, Function> fn) { + return fn.apply(new Builder(collection)).build(); + } + + public ListShardsRequest(Builder builder) { + this(builder.collection, builder.shard); + } + + public static class Builder implements ObjectBuilder { + private final String collection; + private String shard; + + public Builder(String collection) { + this.collection = collection; + } + + public Builder shard(String shard) { + this.shard = shard; + return this; + } + + @Override + public ListShardsRequest build() { + return new ListShardsRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsResponse.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsResponse.java new file mode 100644 index 000000000..d8a66210e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ListShardsResponse.java @@ -0,0 +1,6 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public record ListShardsResponse(@SerializedName("shardingState") ShardingState shardingState) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/Node.java b/src/main/java/io/weaviate/client6/v1/api/cluster/Node.java new file mode 100644 index 000000000..becebc395 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/Node.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record Node( + @SerializedName("name") String name, + @SerializedName("status") NodeStatus status, + /** Commit hash of the Weaviate build the node is running. */ + @SerializedName("gitHash") String gitHash, + /** Weaviate version the node is running. */ + @SerializedName("version") String version, + /** + * Can be {@code null} if "minimal" output is requested. + * + * @see NodeVerbosity#MINIMAL. + */ + @SerializedName("stats") CollectionStats stats, + /** + * Can be {@code null} if "minimal" output is requested. + * + * @see NodeVerbosity#MINIMAL. + */ + @SerializedName("shards") List shards) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/NodeStatus.java b/src/main/java/io/weaviate/client6/v1/api/cluster/NodeStatus.java new file mode 100644 index 000000000..46d9249f2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/NodeStatus.java @@ -0,0 +1,18 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public enum NodeStatus { + /** The node is functional and operating normally. */ + @SerializedName("HEALTHY") + HEALTHY, + /** The node is down after encountering a problem. */ + @SerializedName("UNHEALTHY") + UNHEALTHY, + /** The node is not available. */ + @SerializedName("UNAVAILABLE") + UNAVAILABLE, + /** Liveness probe to a node timed out. */ + @SerializedName("TIMEOUT") + TIMEOUT; +}; diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/NodeVerbosity.java b/src/main/java/io/weaviate/client6/v1/api/cluster/NodeVerbosity.java new file mode 100644 index 000000000..8ee09b363 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/NodeVerbosity.java @@ -0,0 +1,28 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public enum NodeVerbosity implements JsonEnum { + @SerializedName("minimal") + MINIMAL("minimal"), + @SerializedName("verbose") + VERBOSE("verbose"); + + private final String jsonValue; + + private NodeVerbosity(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + + @Override + public String toString() { + return jsonValue(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/Shard.java b/src/main/java/io/weaviate/client6/v1/api/cluster/Shard.java new file mode 100644 index 000000000..e5625a831 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/Shard.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public record Shard( + @SerializedName("name") String name, + @SerializedName("class") String collection, + @SerializedName("objectCount") int objectCount, + @SerializedName("vectorIndexingStatus") VectorIndexingStatus vectorIndexingStatus, + @SerializedName("vectorQueueLenght") int vectorQueueLenght, + @SerializedName("compressed") boolean compressed, + @SerializedName("loaded") boolean loaded, + @SerializedName("numberOfReplicas") int numberOfReplicas, + @SerializedName("replicationFactor") int replicationFactor) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ShardReplica.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ShardReplica.java new file mode 100644 index 000000000..4cd6304e1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ShardReplica.java @@ -0,0 +1,6 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.List; + +public record ShardReplica(String shardName, List replicas) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/ShardingState.java b/src/main/java/io/weaviate/client6/v1/api/cluster/ShardingState.java new file mode 100644 index 000000000..dbca6a795 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/ShardingState.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ShardingState( + @SerializedName("collection") String collection, + @SerializedName("shards") List shards) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/VectorIndexingStatus.java b/src/main/java/io/weaviate/client6/v1/api/cluster/VectorIndexingStatus.java new file mode 100644 index 000000000..b1e58a413 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/VectorIndexingStatus.java @@ -0,0 +1,12 @@ +package io.weaviate.client6.v1.api.cluster; + +import com.google.gson.annotations.SerializedName; + +public enum VectorIndexingStatus { + @SerializedName("READONLY") + READONLY, + @SerializedName("INDEXING") + INDEXING, + @SerializedName("READY") + READY; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClient.java b/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClient.java new file mode 100644 index 000000000..bdd7cac27 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClient.java @@ -0,0 +1,114 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.cluster.replication.CreateReplicationRequest; +import io.weaviate.client6.v1.api.cluster.replication.Replication; +import io.weaviate.client6.v1.api.cluster.replication.ReplicationType; +import io.weaviate.client6.v1.api.cluster.replication.WeaviateReplicationClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateClusterClient { + private final RestTransport restTransport; + + /** + * Client for {@code /replication/replicate} endpoints for managing + * replications. + */ + public final WeaviateReplicationClient replication; + + public WeaviateClusterClient(RestTransport restTransport) { + this.restTransport = restTransport; + this.replication = new WeaviateReplicationClient(restTransport); + } + + /** + * Query sharding state of a collection. + * + * @param collection Collection name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional shardingState(String collection) throws IOException { + return this.restTransport.performRequest(ListShardsRequest.of(collection), ListShardsRequest._ENDPOINT); + } + + /** + * Query sharding state of a collection. + * + * @param collection Collection name. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional shardingState(String collection, + Function> fn) + throws IOException { + return this.restTransport.performRequest(ListShardsRequest.of(collection, fn), ListShardsRequest._ENDPOINT); + } + + /** + * Get the status of all nodes in the cluster. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List listNodes() + throws IOException { + return this.restTransport.performRequest(ListNodesRequest.of(), ListNodesRequest._ENDPOINT); + } + + /** + * Get the status of all nodes in the cluster. + * + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List listNodes(Function> fn) + throws IOException { + return this.restTransport.performRequest(ListNodesRequest.of(fn), ListNodesRequest._ENDPOINT); + } + + /** + * Start a replication operation for a collection's shard. + * + * @param collection Collection name. + * @param shard Shard name. + * @param sourceNode Node on which the shard currently resides. + * @param targetNode Node onto which the files will be replicated. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Replication replicate( + String collection, + String shard, + String sourceNode, + String targetNode, + ReplicationType type) + throws IOException { + return this.restTransport.performRequest( + new CreateReplicationRequest(collection, shard, sourceNode, targetNode, type), + CreateReplicationRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClientAsync.java new file mode 100644 index 000000000..cd00bde24 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/WeaviateClusterClientAsync.java @@ -0,0 +1,83 @@ +package io.weaviate.client6.v1.api.cluster; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.cluster.replication.CreateReplicationRequest; +import io.weaviate.client6.v1.api.cluster.replication.Replication; +import io.weaviate.client6.v1.api.cluster.replication.ReplicationType; +import io.weaviate.client6.v1.api.cluster.replication.WeaviateReplicationClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateClusterClientAsync { + private final RestTransport restTransport; + + public final WeaviateReplicationClientAsync replication; + + public WeaviateClusterClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + this.replication = new WeaviateReplicationClientAsync(restTransport); + } + + /** + * Query sharding state of a collection. + * + * @param collection Collection name. + */ + public CompletableFuture> shardingState(String collection) throws IOException { + return this.restTransport.performRequestAsync(ListShardsRequest.of(collection), ListShardsRequest._ENDPOINT); + } + + /** + * Query sharding state of a collection. + * + * @param collection Collection name. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> shardingState(String collection, + Function> fn) + throws IOException { + return this.restTransport.performRequestAsync(ListShardsRequest.of(collection, fn), ListShardsRequest._ENDPOINT); + } + + /** + * Get the status of all nodes in the cluster. + */ + public CompletableFuture> listNodes() + throws IOException { + return this.restTransport.performRequestAsync(ListNodesRequest.of(), ListNodesRequest._ENDPOINT); + } + + /** + * Get the status of all nodes in the cluster. + * + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> listNodes(Function> fn) + throws IOException { + return this.restTransport.performRequestAsync(ListNodesRequest.of(fn), ListNodesRequest._ENDPOINT); + } + + /** + * Start a replication operation for a collection's shard. + * + * @param collection Collection name. + * @param shard Shard name. + * @param sourceNode Node on which the shard currently resides. + * @param targetNode Node onto which the files will be replicated. + */ + public CompletableFuture replicate( + String collection, + String shard, + String sourceNode, + String targetNode, + ReplicationType type) { + return this.restTransport.performRequestAsync( + new CreateReplicationRequest(collection, shard, sourceNode, targetNode, type), + CreateReplicationRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CancelReplicationRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CancelReplicationRequest.java new file mode 100644 index 000000000..415341b4d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CancelReplicationRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.Collections; +import java.util.UUID; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CancelReplicationRequest(UUID uuid) { + + static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "POST", + request -> "/replication/replicate/" + request.uuid() + "/cancel", + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CreateReplicationRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CreateReplicationRequest.java new file mode 100644 index 000000000..c22a2f2ad --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/CreateReplicationRequest.java @@ -0,0 +1,24 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.Collections; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateReplicationRequest( + @SerializedName("collection") String collection, + @SerializedName("shard") String shard, + @SerializedName("sourceNode") String sourceNode, + @SerializedName("targetNode") String targetNode, + @SerializedName("type") ReplicationType type) { + + public static final Endpoint _ENDPOINT = new SimpleEndpoint<>( + request -> "POST", + request -> "/replication/replicate", + request -> Collections.emptyMap(), + request -> JSON.serialize(request), + (__, response) -> JSON.deserialize(response, Replication.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteAllReplicationsRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteAllReplicationsRequest.java new file mode 100644 index 000000000..649a22729 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteAllReplicationsRequest.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record DeleteAllReplicationsRequest() { + + static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "DELETE", + request -> "/replication/replicate", + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteReplicationRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteReplicationRequest.java new file mode 100644 index 000000000..98666c80f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/DeleteReplicationRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.Collections; +import java.util.UUID; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record DeleteReplicationRequest(UUID uuid) { + + static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "DELETE", + request -> "/replication/replicate/" + request.uuid(), + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/GetReplicationRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/GetReplicationRequest.java new file mode 100644 index 000000000..f56a33c82 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/GetReplicationRequest.java @@ -0,0 +1,56 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.Collections; +import java.util.Optional; +import java.util.UUID; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record GetReplicationRequest(UUID uuid, boolean includeHistory) { + + static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + request -> "GET", + request -> "/replication/replicate/" + request.uuid(), + request -> Collections.singletonMap("includeHistory", request.includeHistory()), + Replication.class); + + public static GetReplicationRequest of(UUID uuid) { + return of(uuid, ObjectBuilder.identity()); + } + + public static GetReplicationRequest of(UUID uuid, Function> fn) { + return fn.apply(new Builder(uuid)).build(); + } + + public GetReplicationRequest(Builder builder) { + this(builder.uuid, builder.includeHistory); + } + + public static class Builder implements ObjectBuilder { + private final UUID uuid; + private boolean includeHistory = false; + + public Builder(UUID uuid) { + this.uuid = uuid; + } + + /** + * Include history of statuses for this replication. + * + * @see Replication#history + */ + public Builder includeHistory(boolean includeHistory) { + this.includeHistory = includeHistory; + return this; + } + + @Override + public GetReplicationRequest build() { + return new GetReplicationRequest(this); + } + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ListReplicationsRequest.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ListReplicationsRequest.java new file mode 100644 index 000000000..032e331f7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ListReplicationsRequest.java @@ -0,0 +1,76 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.HashMap; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListReplicationsRequest(String collection, String shard, String targetNode, boolean includeHistory) { + + static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + request -> "GET", + request -> "/replication/replicate/list", + request -> new HashMap<>() { + { + put("collection", request.collection); + put("shard", request.shard); + put("targetNode", request.targetNode); + put("includeHistory", request.includeHistory); + } + }, + (__, response) -> JSON.deserializeList(response, Replication.class)); + + public static ListReplicationsRequest of() { + return of(ObjectBuilder.identity()); + } + + public static ListReplicationsRequest of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public ListReplicationsRequest(Builder builder) { + this(builder.collection, builder.shard, builder.targetNode, builder.includeHistory); + } + + public static class Builder implements ObjectBuilder { + private String collection; + private String shard; + private String targetNode; + private boolean includeHistory = false; + + public Builder collection(String collection) { + this.collection = collection; + return this; + } + + public Builder shard(String shard) { + this.shard = shard; + return this; + } + + public Builder targetNode(String targetNode) { + this.targetNode = targetNode; + return this; + } + + /** + * Include history of statuses for this replication. + * + * @see Replication#history + */ + public Builder includeHistory(boolean includeHistory) { + this.includeHistory = includeHistory; + return this; + } + + @Override + public ListReplicationsRequest build() { + return new ListReplicationsRequest(this); + } + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/Replication.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/Replication.java new file mode 100644 index 000000000..d55888b4d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/Replication.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.List; +import java.util.UUID; + +import com.google.gson.annotations.SerializedName; + +public record Replication( + /** Operation UUID. */ + @SerializedName("id") UUID uuid, + @SerializedName("collection") String collection, + @SerializedName("shard") String shard, + @SerializedName("sourceNode") String sourceNode, + @SerializedName("targetNode") String targetNode, + @SerializedName("type") ReplicationType type, + @SerializedName("status") ReplicationStatus status, + /** Absent if {@code includeHistory} not enabled. */ + @SerializedName("statusHistory") List history) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationState.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationState.java new file mode 100644 index 000000000..61df883ee --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationState.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import com.google.gson.annotations.SerializedName; + +public enum ReplicationState { + @SerializedName("REGISTERED") + REGISTERED, + @SerializedName("HYDRATING") + HYDRATING, + @SerializedName("FINALIZING") + FINALIZING, + @SerializedName("DEHYDRATING") + DEHYDRATING, + @SerializedName("READY") + READY, + @SerializedName("CANCELLED") + CANCELED, + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationStatus.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationStatus.java new file mode 100644 index 000000000..0972ddf68 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationStatus.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ReplicationStatus( + @SerializedName("state") ReplicationState state, + @SerializedName("errors") List errors) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationType.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationType.java new file mode 100644 index 000000000..f099eb00b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/ReplicationType.java @@ -0,0 +1,12 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import com.google.gson.annotations.SerializedName; + +public enum ReplicationType { + /** A copy of the shard is created on the target node. */ + @SerializedName("COPY") + COPY, + /** Shard is moved to the target node and is deleted from the source node. */ + @SerializedName("MOVE") + MOVE; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClient.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClient.java new file mode 100644 index 000000000..1b48eabb5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClient.java @@ -0,0 +1,124 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateReplicationClient { + private final RestTransport restTransport; + + public WeaviateReplicationClient(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Get information about a replication operation. + * + * @param uuid Replication UUID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional get(UUID uuid) throws IOException { + return this.restTransport.performRequest(GetReplicationRequest.of(uuid), GetReplicationRequest._ENDPOINT); + } + + /** + * Get information about a replication operation. + * + * @param uuid Replication UUID. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional get(UUID uuid, + Function> fn) throws IOException { + return this.restTransport.performRequest(GetReplicationRequest.of(uuid, fn), GetReplicationRequest._ENDPOINT); + } + + /** + * List all replication operations. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * @see WeaviateReplicationClient#list(Function) for filtering replications by + * collection, shard, or target node. + */ + public List list() + throws IOException { + return this.restTransport.performRequest(ListReplicationsRequest.of(), ListReplicationsRequest._ENDPOINT); + } + + /** + * List all replication operations. + * + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list(Function> fn) + throws IOException { + return this.restTransport.performRequest(ListReplicationsRequest.of(fn), ListReplicationsRequest._ENDPOINT); + } + + /** + * Cancel a replication operation. + * + * @param uuid Replication UUID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void cancel(UUID uuid) + throws IOException { + this.restTransport.performRequest(new CancelReplicationRequest(uuid), CancelReplicationRequest._ENDPOINT); + } + + /** + * Delete a replication operation. + * + * @param uuid Replication UUID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(UUID uuid) + throws IOException { + this.restTransport.performRequest(new DeleteReplicationRequest(uuid), DeleteReplicationRequest._ENDPOINT); + } + + /** + * Delete all replication operations. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void deleteAll() + throws IOException { + this.restTransport.performRequest(null, DeleteAllReplicationsRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClientAsync.java new file mode 100644 index 000000000..058360124 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/cluster/replication/WeaviateReplicationClientAsync.java @@ -0,0 +1,90 @@ +package io.weaviate.client6.v1.api.cluster.replication; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateReplicationClientAsync { + private final RestTransport restTransport; + + public WeaviateReplicationClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Get information about a replication operation. + * + * @param uuid Replication UUID. + */ + public CompletableFuture> get(UUID uuid) throws IOException { + return this.restTransport.performRequestAsync(GetReplicationRequest.of(uuid), GetReplicationRequest._ENDPOINT); + } + + /** + * Get information about a replication operation. + * + * @param uuid Replication UUID. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> get(UUID uuid, + Function> fn) throws IOException { + return this.restTransport.performRequestAsync(GetReplicationRequest.of(uuid, fn), GetReplicationRequest._ENDPOINT); + } + + /** + * List all replication operations. + * + * @see WeaviateReplicationClientAsync#list(Function) for filtering replications + * by + * collection, shard, or target node. + */ + public CompletableFuture> list() + throws IOException { + return this.restTransport.performRequestAsync(ListReplicationsRequest.of(), ListReplicationsRequest._ENDPOINT); + } + + /** + * List all replication operations. + * + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> list( + Function> fn) + throws IOException { + return this.restTransport.performRequestAsync(ListReplicationsRequest.of(fn), ListReplicationsRequest._ENDPOINT); + } + + /** + * Cancel a replication operation. + * + * @param uuid Replication UUID. + */ + public CompletableFuture cancel(UUID uuid) + throws IOException { + return this.restTransport.performRequestAsync(new CancelReplicationRequest(uuid), + CancelReplicationRequest._ENDPOINT); + } + + /** + * Delete a replication operation. + * + * @param uuid Replication UUID. + */ + public CompletableFuture delete(UUID uuid) + throws IOException { + return this.restTransport.performRequestAsync(new DeleteReplicationRequest(uuid), + DeleteReplicationRequest._ENDPOINT); + } + + /** Delete all replication operations. */ + public CompletableFuture deleteAll() + throws IOException { + return this.restTransport.performRequestAsync(null, DeleteAllReplicationsRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionConfig.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionConfig.java new file mode 100644 index 000000000..fa7bf4099 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionConfig.java @@ -0,0 +1,369 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.annotations.SerializedName; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record CollectionConfig( + /** Collection name. */ + @SerializedName("class") String collectionName, + /** Collection description. */ + @SerializedName("description") String description, + /** Collection properties. */ + @SerializedName("properties") List properties, + /** Cross-reference properties. */ + List references, + /** Vector indexes configured for this collection. */ + @SerializedName("vectorConfig") Map vectors, + /** Multi-tenancy options. */ + @SerializedName("multiTenancyConfig") MultiTenancy multiTenancy, + /** Sharding configuration. */ + @SerializedName("shardingConfig") Sharding sharding, + /** Replication configuration. */ + @SerializedName("replicationConfig") Replication replication, + /** Inverted index configuration. */ + @SerializedName("invertedIndexConfig") InvertedIndex invertedIndex, + @SerializedName("objectTtlConfig") ObjectTtl objectTtl, + /** Reranker modules. */ + List rerankerModules, + /** Generative modules. */ + Generative generativeModule) { + + public static CollectionConfig of(String collectionName) { + return of(collectionName, ObjectBuilder.identity()); + } + + public static CollectionConfig of(String collectionName, Function> fn) { + return fn.apply(new Builder(collectionName)).build(); + } + + /** + * Returns a {@link Builder} with all current values of + * {@code WeaviateCollection} pre-filled. + */ + public Builder edit() { + return new Builder(collectionName) + .description(description) + .properties(properties) + .references(references) + .vectorConfig(vectors) + .multiTenancy(multiTenancy) + .sharding(sharding) + .replication(replication) + .invertedIndex(invertedIndex) + .objectTtl(objectTtl) + .rerankerModules(rerankerModules != null ? rerankerModules : new ArrayList<>()) + .generativeModule(generativeModule); + } + + /** Create a copy of this {@code WeaviateCollection} and edit parts of it. */ + public CollectionConfig edit(Function> fn) { + return fn.apply(edit()).build(); + } + + public CollectionConfig(Builder builder) { + this( + builder.collectionName, + builder.description, + builder.propertyList(), + builder.referenceList(), + builder.vectors, + builder.multiTenancy, + builder.sharding, + builder.replication, + builder.invertedIndex, + builder.objectTtl, + builder.rerankerModules, + builder.generativeModule); + } + + public static class Builder implements ObjectBuilder { + // Required parameters; + private final String collectionName; + + private String description; + private Map properties = new HashMap<>(); + private Map references = new HashMap<>(); + private Map vectors = new HashMap<>(); + private MultiTenancy multiTenancy; + private Sharding sharding; + private Replication replication; + private InvertedIndex invertedIndex; + private ObjectTtl objectTtl; + private List rerankerModules = new ArrayList<>(); + private Generative generativeModule; + + public Builder(String collectionName) { + this.collectionName = collectionName; + } + + /** Add collection description. */ + public Builder description(String description) { + this.description = description; + return this; + } + + /** + * Add collection properties. + * + * @see Property + */ + public Builder properties(Property... properties) { + return properties(Arrays.asList(properties)); + } + + /** + * Add collection properties. + * + * @see Property + */ + public Builder properties(List properties) { + properties.forEach(property -> this.properties.put(property.propertyName(), property)); + return this; + } + + private List propertyList() { + return this.properties.values().stream().toList(); + } + + /** + * Add cross-reference properties. + * + * @see ReferenceProperty#to + */ + public Builder references(ReferenceProperty... references) { + return references(Arrays.asList(references)); + } + + /** + * Add cross-reference properties. + * + * @see ReferenceProperty#to + */ + public Builder references(List references) { + references.forEach(reference -> this.references.put(reference.propertyName(), reference)); + return this; + } + + private List referenceList() { + return this.references.values().stream().toList(); + } + + /** Add vector index configurations. */ + public final Builder vectorConfig(Map vectors) { + this.vectors.putAll(vectors); + return this; + } + + /** + * Add vector index configurations. + * + * @see VectorConfig + */ + @SafeVarargs + public final Builder vectorConfig(Map.Entry... vectors) { + this.vectors.putAll(Map.ofEntries(vectors)); + return this; + } + + /** Configure collection's sharding. */ + public Builder sharding(Sharding sharding) { + this.sharding = sharding; + return this; + } + + /** Configure collection's sharding. */ + public Builder sharding(Function> fn) { + this.sharding(Sharding.of(fn)); + return this; + } + + /** Configure multi-tenancy. */ + public Builder multiTenancy(Function> fn) { + return multiTenancy(MultiTenancy.of(fn)); + } + + /** Configure multi-tenancy. */ + public Builder multiTenancy(MultiTenancy multiTenancy) { + this.multiTenancy = multiTenancy; + return this; + } + + /** Configure replication. */ + public Builder replication(Replication replication) { + this.replication = replication; + return this; + } + + /** Configure replication. */ + public Builder replication(Function> fn) { + this.replication(Replication.of(fn)); + return this; + } + + /** Change inverted index configurations. */ + public Builder invertedIndex(InvertedIndex invertedIndex) { + this.invertedIndex = invertedIndex; + return this; + } + + /** Change inverted index configurations. */ + public Builder invertedIndex(Function> fn) { + this.invertedIndex(InvertedIndex.of(fn)); + return this; + } + + /** Change inverted index configurations. */ + public Builder objectTtl(ObjectTtl objectTtl) { + this.objectTtl = objectTtl; + return this; + } + + /** Change object TTL configuration. */ + public Builder objectTtl(Function> fn) { + this.objectTtl(ObjectTtl.of(fn)); + return this; + } + + /** Add reranker modules. */ + public Builder rerankerModules(Reranker... rerankerModules) { + return rerankerModules(Arrays.asList(rerankerModules)); + } + + /** Add reranker modules. */ + public Builder rerankerModules(List rerankerModules) { + this.rerankerModules.addAll(rerankerModules); + return this; + } + + /** Add a generative module. */ + public Builder generativeModule(Generative generativeModule) { + this.generativeModule = generativeModule; + return this; + } + + @Override + public CollectionConfig build() { + return new CollectionConfig(this); + } + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + if (type.getRawType() != CollectionConfig.class) { + return null; + } + + final var delegate = gson.getDelegateAdapter(this, (TypeToken) type); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, CollectionConfig value) throws IOException { + var jsonObject = delegate.toJsonTree(value).getAsJsonObject(); + + // References must be merged with properties. + var references = jsonObject.remove("references").getAsJsonArray(); + var properties = jsonObject.get("properties").getAsJsonArray(); + properties.addAll(references); + + // Reranker and Generative module configs belong to the "moduleConfig". + var rerankerModules = jsonObject.remove("rerankerModules").getAsJsonArray(); + var generativeModule = jsonObject.remove("generativeModule"); + + var modules = new JsonObject(); + if (!rerankerModules.isEmpty()) { + // Copy configuration for each reranker module. + rerankerModules.forEach(reranker -> { + reranker.getAsJsonObject().entrySet() + .stream().forEach(entry -> modules.add(entry.getKey(), entry.getValue())); + }); + } + + if (!generativeModule.isJsonNull()) { + // Copy configuration for each generative module. + generativeModule.getAsJsonObject().entrySet() + .stream().forEach(entry -> modules.add(entry.getKey(), entry.getValue())); + } + + if (!modules.isEmpty()) { + jsonObject.add("moduleConfig", modules); + } + + Streams.write(jsonObject, out); + } + + @Override + public CollectionConfig read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + + var references = new JsonArray(); + var properties = new JsonArray(); + + if (jsonObject.has("properties") && jsonObject.get("properties").isJsonArray()) { + var mixedProperties = jsonObject.get("properties").getAsJsonArray(); + + for (var property : mixedProperties) { + var dataTypes = property.getAsJsonObject().get("dataType").getAsJsonArray(); + if (dataTypes.size() == 1 && DataType.KNOWN_TYPES.contains(dataTypes.get(0).getAsString())) { + properties.add(property); + } else { + references.add(property); + } + } + } + + jsonObject.add("properties", properties); + jsonObject.add("references", references); + + if (!jsonObject.has("vectorConfig")) { + jsonObject.add("vectorConfig", new JsonObject()); + } + + // Separate modules into reranker- and generative- modules. + var rerankerModules = new JsonArray(); + if (jsonObject.has("moduleConfig") && jsonObject.get("moduleConfig").isJsonObject()) { + var moduleConfig = jsonObject.remove("moduleConfig").getAsJsonObject(); + + moduleConfig.entrySet().stream() + .forEach(entry -> { + var module = new JsonObject(); + var name = entry.getKey(); + module.add(name, entry.getValue()); + + if (name.startsWith("reranker-")) { + rerankerModules.add(module); + } else if (name.startsWith("generative-")) { + jsonObject.add("generativeModule", module); + } + }); + } + jsonObject.add("rerankerModules", rerankerModules); + + return delegate.fromJsonTree(jsonObject); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java new file mode 100644 index 000000000..7af8ed549 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java @@ -0,0 +1,142 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collection; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.WeaviateAggregateClient; +import io.weaviate.client6.v1.api.collections.config.WeaviateConfigClient; +import io.weaviate.client6.v1.api.collections.data.WeaviateDataClient; +import io.weaviate.client6.v1.api.collections.generate.WeaviateGenerateClient; +import io.weaviate.client6.v1.api.collections.pagination.Paginator; +import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClient; +import io.weaviate.client6.v1.api.collections.tenants.WeaviateTenantsClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class CollectionHandle { + public final WeaviateConfigClient config; + public final WeaviateDataClient data; + public final WeaviateQueryClient query; + public final WeaviateAggregateClient aggregate; + public final WeaviateGenerateClient generate; + public final WeaviateTenantsClient tenants; + + private final CollectionHandleDefaults defaults; + + public CollectionHandle( + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + this.config = new WeaviateConfigClient(collection, restTransport, grpcTransport, defaults); + this.aggregate = new WeaviateAggregateClient(collection, grpcTransport, defaults); + this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults); + this.generate = new WeaviateGenerateClient<>(collection, grpcTransport, defaults); + this.data = new WeaviateDataClient<>(collection, restTransport, grpcTransport, defaults); + this.defaults = defaults; + + this.tenants = new WeaviateTenantsClient(collection, restTransport, grpcTransport); + } + + /** Copy constructor that sets new defaults. */ + private CollectionHandle(CollectionHandle c, CollectionHandleDefaults defaults) { + this.config = new WeaviateConfigClient(c.config, defaults); + this.aggregate = new WeaviateAggregateClient(c.aggregate, defaults); + this.query = new WeaviateQueryClient<>(c.query, defaults); + this.generate = new WeaviateGenerateClient<>(c.generate, defaults); + this.data = new WeaviateDataClient<>(c.data, defaults); + this.defaults = defaults; + + this.tenants = c.tenants; + } + + /** + * Create a Paginator over the objects in this collection. + * + *

+ * Usage: + * + *

+   * {@code
+   * var things = client.collections.use("Things");
+   *
+   * // In a for-loop:
+   * for (final var thing : things.paginate()) {
+   *   // ... do something for each Thing object
+   * }
+   *
+   * // As a stream
+   * things.paginate().stream()
+   *  .map(...)
+   *  .collect(...);
+   * }
+ * + * @return An {@link Iterable} over this collection's objects. + */ + public Paginator paginate() { + return Paginator.of(this.query); + } + + /** + * Create a Paginator over the objects in this collection. + * + * @param fn Lambda expression for optional parameters. + * @return An {@link Iterable} over this collection's objects. + */ + public Paginator paginate( + Function, ObjectBuilder>> fn) { + return Paginator.of(this.query, fn); + } + + /** + * Get the object count in this collection. + * + *

+ * While made to resemeble {@link Collection#size}, counting Weaviate collection + * objects involves making a network call, making this a blocking operation. + * This method also does not define behaviour for cases where the size of the + * collection exceeds {@link Long#MAX_VALUE} as this is unlikely to happen. + * + *

+ * This is a shorthand for: + * + *

{@code
+   * handle.aggregate.overAll(all -> all.includeTotalCount(true)).totalCount()
+   * }
+ */ + public long size() { + return this.aggregate.overAll(all -> all.includeTotalCount(true)).totalCount(); + } + + /** Default consistency level for requests. */ + public ConsistencyLevel consistencyLevel() { + return defaults.consistencyLevel(); + } + + /** Obtain a collection handle with a different consistency level. */ + public CollectionHandle withConsistencyLevel(ConsistencyLevel consistencyLevel) { + return new CollectionHandle<>(this, CollectionHandleDefaults.of(with -> with.consistencyLevel(consistencyLevel))); + } + + /** Default tenant for requests. */ + public String tenant() { + return defaults.tenant(); + } + + /** Obtain a collection handle with a different target tenant. */ + public CollectionHandle withTenant(String tenant) { + return new CollectionHandle<>(this, CollectionHandleDefaults.of(with -> with.tenant(tenant))); + } + + /** + * Obtain a collection handle with different defaults + * (consistency level / tenant). + */ + public CollectionHandle withDefaults( + Function> fn) { + return new CollectionHandle<>(this, CollectionHandleDefaults.of(fn)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java new file mode 100644 index 000000000..83d18ed2f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java @@ -0,0 +1,121 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collection; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateResponse; +import io.weaviate.client6.v1.api.collections.aggregate.WeaviateAggregateClientAsync; +import io.weaviate.client6.v1.api.collections.config.WeaviateConfigClientAsync; +import io.weaviate.client6.v1.api.collections.data.WeaviateDataClientAsync; +import io.weaviate.client6.v1.api.collections.generate.WeaviateGenerateClientAsync; +import io.weaviate.client6.v1.api.collections.pagination.AsyncPaginator; +import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClientAsync; +import io.weaviate.client6.v1.api.collections.tenants.WeaviateTenantsClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class CollectionHandleAsync { + public final WeaviateConfigClientAsync config; + public final WeaviateDataClientAsync data; + public final WeaviateQueryClientAsync query; + public final WeaviateGenerateClientAsync generate; + public final WeaviateAggregateClientAsync aggregate; + public final WeaviateTenantsClientAsync tenants; + + private final CollectionHandleDefaults defaults; + + public CollectionHandleAsync( + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + + this.config = new WeaviateConfigClientAsync(collection, restTransport, grpcTransport, defaults); + this.aggregate = new WeaviateAggregateClientAsync(collection, grpcTransport, defaults); + this.query = new WeaviateQueryClientAsync<>(collection, grpcTransport, defaults); + this.generate = new WeaviateGenerateClientAsync<>(collection, grpcTransport, defaults); + this.data = new WeaviateDataClientAsync<>(collection, restTransport, grpcTransport, defaults); + this.defaults = defaults; + + this.tenants = new WeaviateTenantsClientAsync(collection, restTransport, grpcTransport); + } + + /** Copy constructor that sets new defaults. */ + private CollectionHandleAsync(CollectionHandleAsync c, CollectionHandleDefaults defaults) { + this.config = new WeaviateConfigClientAsync(c.config, defaults); + this.aggregate = new WeaviateAggregateClientAsync(c.aggregate, defaults); + this.query = new WeaviateQueryClientAsync<>(c.query, defaults); + this.generate = new WeaviateGenerateClientAsync<>(c.generate, defaults); + this.data = new WeaviateDataClientAsync<>(c.data, defaults); + this.defaults = defaults; + + this.tenants = c.tenants; + } + + public AsyncPaginator paginate() { + return AsyncPaginator.of(this.query); + } + + public AsyncPaginator paginate( + Function, ObjectBuilder>> fn) { + return AsyncPaginator.of(this.query, fn); + } + + /** + * Get the object count in this collection. + * + *

+ * While made to resemeble {@link Collection#size}, counting Weaviate collection + * objects involves making a network call; still, this operation is + * non-blocking, as resolving the underlying {@code CompletableFuture} is + * deferred to the caller. + * + * This method also does not define behaviour for cases where the size of the + * collection exceeds {@link Long#MAX_VALUE} as this is unlikely to happen. + * + *

+ * This is a shortcut for: + * + *

{@code
+   * handle.aggregate.overAll(all -> all.includeTotalCount(true)).totalCount()
+   * }
+ */ + public CompletableFuture size() { + return this.aggregate.overAll(all -> all.includeTotalCount(true)) + .thenApply(AggregateResponse::totalCount); + } + + /** Default consistency level for requests. */ + public ConsistencyLevel consistencyLevel() { + return defaults.consistencyLevel(); + } + + /** Obtain a collection handle with a different consistency level. */ + public CollectionHandleAsync withConsistencyLevel(ConsistencyLevel consistencyLevel) { + return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of( + def -> def.consistencyLevel(consistencyLevel))); + } + + /** Default tenant for requests. */ + public String tenant() { + return defaults.tenant(); + } + + /** Obtain a collection handle with a different target tenant. */ + public CollectionHandleAsync withTenant(String tenant) { + return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of(with -> with.tenant(tenant))); + } + + /** + * Obtain a collection handle with different defaults + * (consistency level / tenant). + */ + public CollectionHandleAsync withDefaults( + Function> fn) { + return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of(fn)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java new file mode 100644 index 000000000..c7952222a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java @@ -0,0 +1,71 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record CollectionHandleDefaults(ConsistencyLevel consistencyLevel, String tenant) { + /** + * Set default values for query / aggregation requests. + * + * @return CollectionHandleDefaults derived from applying {@code fn} to + * {@link Builder}. + */ + public static CollectionHandleDefaults of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Empty collection defaults. + * + * @return A tucked builder that does not leaves all defaults unset. + */ + public static Function> none() { + return ObjectBuilder.identity(); + } + + public CollectionHandleDefaults(Builder builder) { + this(builder.consistencyLevel, builder.tenant); + } + + public static final class Builder implements ObjectBuilder { + private ConsistencyLevel consistencyLevel; + private String tenant; + + /** Set default consistency level for this collection handle. */ + public Builder consistencyLevel(ConsistencyLevel consistencyLevel) { + this.consistencyLevel = consistencyLevel; + return this; + } + + /** Set default tenant for this collection handle. */ + public Builder tenant(String tenant) { + this.tenant = tenant; + return this; + } + + @Override + public CollectionHandleDefaults build() { + return new CollectionHandleDefaults(this); + } + } + + /** Serialize default values to a URL query. */ + public Map queryParameters() { + if (consistencyLevel == null && tenant == null) { + return Collections.emptyMap(); + } + var query = new HashMap(); + if (consistencyLevel != null) { + query.put("consistency_level", consistencyLevel); + } + if (tenant != null) { + query.put("tenant", tenant); + } + return query; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CreateCollectionRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/CreateCollectionRequest.java new file mode 100644 index 000000000..a22957328 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/CreateCollectionRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateCollectionRequest(CollectionConfig collection) { + public static final Endpoint _ENDPOINT = new SimpleEndpoint<>( + request -> "POST", + request -> "/schema/", + request -> Collections.emptyMap(), + request -> JSON.serialize(request.collection), + (statusCode, response) -> JSON.deserialize(response, CollectionConfig.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/DataType.java b/src/main/java/io/weaviate/client6/v1/api/collections/DataType.java new file mode 100644 index 000000000..62f529be8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/DataType.java @@ -0,0 +1,41 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Set; + +import com.google.common.collect.ImmutableSet; + +public interface DataType { + public static final String TEXT = "text"; + public static final String TEXT_ARRAY = "text[]"; + public static final String INT = "int"; + public static final String INT_ARRAY = "int[]"; + public static final String NUMBER = "number"; + public static final String NUMBER_ARRAY = "number[]"; + public static final String BOOL = "boolean"; + public static final String BOOL_ARRAY = "boolean[]"; + public static final String BLOB = "blob"; + public static final String DATE = "date"; + public static final String DATE_ARRAY = "date[]"; + public static final String UUID = "uuid"; + public static final String UUID_ARRAY = "uuid[]"; + public static final String OBJECT = "object"; + public static final String OBJECT_ARRAY = "object[]"; + public static final String PHONE_NUMBER = "phoneNumber"; + public static final String GEO_COORDINATES = "geoCoordinates"; + + /** + * Scalar/array types which Weaviate and WeaviateClient recognize. + * + *

+ * Other data types are considered reference types, i.e. if a user creates a + * property with type {@code "timestamp"}, the client will count it a + * cross-reference to the {@code "timestamp"} collection. + * + * This is obviously wrong, so it is recommended to always create properties + * using {@link Property}'s factory classes. + */ + public static final Set KNOWN_TYPES = ImmutableSet.of( + TEXT, INT, BLOB, BOOL, DATE, UUID, NUMBER, OBJECT, + TEXT_ARRAY, INT_ARRAY, NUMBER_ARRAY, BOOL_ARRAY, DATE_ARRAY, UUID_ARRAY, OBJECT_ARRAY, + PHONE_NUMBER, GEO_COORDINATES); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/DeleteCollectionRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/DeleteCollectionRequest.java new file mode 100644 index 000000000..02d184986 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/DeleteCollectionRequest.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record DeleteCollectionRequest(String collectionName) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "DELETE", + request -> "/schema/" + request.collectionName, + request -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Encoding.java b/src/main/java/io/weaviate/client6/v1/api/collections/Encoding.java new file mode 100644 index 000000000..a52d20657 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Encoding.java @@ -0,0 +1,108 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.encoding.MuveraEncoding; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface Encoding { + + enum Kind implements JsonEnum { + MUVERA("muvera"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + Kind _kind(); + + Object _self(); + + public static Encoding muvera() { + return MuveraEncoding.of(); + } + + public static Encoding muvera(Function> fn) { + return MuveraEncoding.of(fn); + } + + public enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> delegateAdapters = new EnumMap<>( + Encoding.Kind.class); + + private final void addAdapter(Gson gson, Encoding.Kind kind, Class cls) { + delegateAdapters.put(kind, + (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, Encoding.Kind.MUVERA, MuveraEncoding.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + final var rawType = type.getRawType(); + if (!Encoding.class.isAssignableFrom(rawType)) { + return null; + } + + if (delegateAdapters.isEmpty()) { + init(gson); + } + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Encoding value) throws IOException { + TypeAdapter adapter = (TypeAdapter) delegateAdapters.get(value._kind()); + adapter.write(out, (T) value._self()); + } + + @Override + public Encoding read(JsonReader in) throws IOException { + var encodingObject = JsonParser.parseReader(in).getAsJsonObject(); + var encodingName = encodingObject.keySet().iterator().next(); + + Encoding.Kind kind; + try { + kind = Encoding.Kind.valueOfJson(encodingName); + } catch (IllegalArgumentException e) { + return null; + } + + var adapter = delegateAdapters.get(kind); + var concreteEncoding = encodingObject.get(encodingName).getAsJsonObject(); + return adapter.fromJsonTree(concreteEncoding); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Generative.java b/src/main/java/io/weaviate/client6/v1/api/collections/Generative.java new file mode 100644 index 000000000..55c622ff7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Generative.java @@ -0,0 +1,583 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.generative.AnthropicGenerative; +import io.weaviate.client6.v1.api.collections.generative.AnyscaleGenerative; +import io.weaviate.client6.v1.api.collections.generative.AwsGenerative; +import io.weaviate.client6.v1.api.collections.generative.AzureOpenAiGenerative; +import io.weaviate.client6.v1.api.collections.generative.CohereGenerative; +import io.weaviate.client6.v1.api.collections.generative.DatabricksGenerative; +import io.weaviate.client6.v1.api.collections.generative.DummyGenerative; +import io.weaviate.client6.v1.api.collections.generative.FriendliaiGenerative; +import io.weaviate.client6.v1.api.collections.generative.GoogleGenerative; +import io.weaviate.client6.v1.api.collections.generative.MistralGenerative; +import io.weaviate.client6.v1.api.collections.generative.NvidiaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OllamaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OpenAiGenerative; +import io.weaviate.client6.v1.api.collections.generative.XaiGenerative; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.TaggedUnion; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface Generative extends TaggedUnion { + public enum Kind implements JsonEnum { + ANYSCALE("generative-anyscale"), + AWS("generative-aws"), + ANTHROPIC("generative-anthropic"), + COHERE("generative-cohere"), + DATABRICKS("generative-databricks"), + FRIENDLIAI("generative-friendliai"), + GOOGLE("generative-google"), + MISTRAL("generative-mistral"), + NVIDIA("generative-nvidia"), + OLLAMA("generative-ollama"), + OPENAI("generative-openai"), + AZURE_OPENAI("generative-openai"), + XAI("generative-xai"), + DUMMY("generative-dummy"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + /** Configure a default {@code generative-anthropic} module. */ + public static Generative anthropic() { + return AnthropicGenerative.of(); + } + + /** + * Configure a {@code generative-anthropic} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative anthropic(Function> fn) { + return AnthropicGenerative.of(fn); + } + + /** Configure a default {@code generative-anyscale} module. */ + public static Generative anyscale() { + return AnyscaleGenerative.of(); + } + + /** + * Configure a {@code generative-anyscale} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative anyscale(Function> fn) { + return AnyscaleGenerative.of(fn); + } + + /** + * Configure a default {@code generative-aws} module with Bedrock integration. + * + * @param region AWS region. + * @param model Model to use with Bedrock service. + */ + public static Generative awsBedrock(String region, String model) { + return AwsGenerative.bedrock(region, model); + } + + /** + * Configure a {@code generative-aws} module with Bedrock integration. + * + * @param region AWS region. + * @param model Model to use with Bedrock service. + * @param fn Lambda expression for optional parameters. + */ + public static Generative awsBedrock(String region, String model, + Function> fn) { + return AwsGenerative.bedrock(region, model, fn); + } + + /** + * Configure a default {@code generative-aws} module with Sagemaker integration. + * + * @param region AWS region. + * @param endpoint Base inference URL. + */ + public static Generative awsSagemaker(String region, String endpoint) { + return AwsGenerative.sagemaker(region, endpoint); + } + + /** + * Configure a {@code generative-aws} module with Sagemaker integration. + * + * @param region AWS region. + * @param endpoint Base inference URL. + * @param fn Lambda expression for optional parameters. + */ + public static Generative awsSagemaker(String region, String endpoint, + Function> fn) { + return AwsGenerative.sagemaker(region, endpoint, fn); + } + + /** Configure a default {@code generative-cohere} module. */ + public static Generative cohere() { + return CohereGenerative.of(); + } + + /** + * Configure a {@code generative-cohere} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative cohere(Function> fn) { + return CohereGenerative.of(fn); + } + + /** + * Configure a default {@code generative-databricks} module. + * + * @param endpoint Base URL for the generative service. + */ + public static Generative databricks(String endpoint) { + return DatabricksGenerative.of(endpoint); + } + + /** + * Configure a {@code generative-databricks} module. + * + * @param endpoint Base URL for the generative service. + * @param fn Lambda expression for optional parameters. + */ + public static Generative databricks(String endpoint, + Function> fn) { + return DatabricksGenerative.of(endpoint, fn); + } + + /** Configure a default {@code generative-frienliai} module. */ + public static Generative frienliai() { + return FriendliaiGenerative.of(); + } + + /** + * Configure a {@code generative-frienliai} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative friendliai(Function> fn) { + return FriendliaiGenerative.of(fn); + } + + /** Configure a default {@code generative-google} module. */ + public static Generative googleVertex(String projectId) { + return GoogleGenerative.vertex(projectId); + } + + /** + * Configure a {@code generative-google} module. + * + * @param projectId Project ID. + * @param fn Lambda expression for optional parameters. + */ + public static Generative googleVertex(String projectId, + Function> fn) { + return GoogleGenerative.vertex(projectId, fn); + } + + /** Configure a default {@code generative-google} module. */ + public static Generative googleAiStudio() { + return GoogleGenerative.aiStudio(); + } + + /** + * Configure a {@code generative-google} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative googleAiStudio( + Function> fn) { + return GoogleGenerative.aiStudio(fn); + } + + /** Configure a default {@code generative-mistral} module. */ + public static Generative mistral() { + return MistralGenerative.of(); + } + + /** + * Configure a {@code generative-mistral} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative mistral(Function> fn) { + return MistralGenerative.of(fn); + } + + /** Configure a default {@code generative-nvidia} module. */ + public static Generative nvidia() { + return NvidiaGenerative.of(); + } + + /** + * Configure a {@code generative-nvidia} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative nvidia(Function> fn) { + return NvidiaGenerative.of(fn); + } + + /** Configure a default {@code generative-ollama} module. */ + public static Generative ollama() { + return OllamaGenerative.of(); + } + + /** + * Configure a {@code generative-ollama} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative ollama(Function> fn) { + return OllamaGenerative.of(fn); + } + + /** Configure a default {@code generative-openai} module. */ + public static Generative openai() { + return OpenAiGenerative.of(); + } + + /** + * Configure a {@code generative-openai} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative openai(Function> fn) { + return OpenAiGenerative.of(fn); + } + + /** + * Configure a default {@code generative-openai} module + * hosted on Microsoft Azure. + * + * @param resourceName Name of the Azure OpenAI resource. + * @param deploymentId Azure OpenAI deployment ID. + */ + public static Generative azure(String resourceName, String deploymentId) { + return AzureOpenAiGenerative.of(resourceName, deploymentId); + } + + /** + * Configure a {@code generative-openai} module hosted on Microsoft Azure. + * + * @param resourceName Name of the Azure OpenAI resource. + * @param deploymentId Azure OpenAI deployment ID. + * @param fn Lambda expression for optional parameters. + */ + public static Generative azure(String resourceName, String deploymentId, + Function> fn) { + return AzureOpenAiGenerative.of(resourceName, deploymentId, fn); + } + + /** Configure a default {@code generative-xai} module. */ + public static Generative xai() { + return XaiGenerative.of(); + } + + /** + * Configure a {@code generative-xai} module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Generative xai(Function> fn) { + return XaiGenerative.of(fn); + } + + /** Is this a {@code generative-anyscale} provider? */ + default boolean isAnyscale() { + return _is(Generative.Kind.ANYSCALE); + } + + /** + * Get as {@link AnyscaleGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-anyscale}. + */ + default AnyscaleGenerative asAnyscale() { + return _as(Generative.Kind.ANYSCALE); + } + + /** Is this a {@code generative-aws} provider? */ + default boolean isAws() { + return _is(Generative.Kind.AWS); + } + + /** + * Get as {@link AwsGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-aws}. + */ + default AwsGenerative asAws() { + return _as(Generative.Kind.AWS); + } + + /** Is this a {@code generative-anthropic} provider? */ + default boolean isAnthropic() { + return _is(Generative.Kind.ANTHROPIC); + } + + /** + * Get as {@link AnthropicGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-anthropic}. + */ + default AnthropicGenerative asAnthropic() { + return _as(Generative.Kind.ANTHROPIC); + } + + /** Is this a {@code generative-cohere} provider? */ + default boolean isCohere() { + return _is(Generative.Kind.COHERE); + } + + /** + * Get as {@link CohereGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-cohere}. + */ + default CohereGenerative asCohere() { + return _as(Generative.Kind.COHERE); + } + + /** Is this a {@code generative-databricks} provider? */ + default boolean isDatabricks() { + return _is(Generative.Kind.DATABRICKS); + } + + /** + * Get as {@link DatabricksGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-databricks}. + */ + default DatabricksGenerative asDatabricks() { + return _as(Generative.Kind.DATABRICKS); + } + + /** Is this a {@code generative-friendliai} provider? */ + default boolean isFriendliai() { + return _is(Generative.Kind.FRIENDLIAI); + } + + /** + * Get as {@link FriendliaiGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-friendliai}. + */ + default FriendliaiGenerative asFriendliai() { + return _as(Generative.Kind.FRIENDLIAI); + } + + /** Is this a {@code generative-google} provider? */ + default boolean isGoogle() { + return _is(Generative.Kind.GOOGLE); + } + + /** + * Get as {@link GoogleGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-google}. + */ + default GoogleGenerative asGoogle() { + return _as(Generative.Kind.GOOGLE); + } + + /** Is this a {@code generative-mistral} provider? */ + default boolean isMistral() { + return _is(Generative.Kind.MISTRAL); + } + + /** + * Get as {@link MistralGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-mistral}. + */ + default MistralGenerative asMistral() { + return _as(Generative.Kind.MISTRAL); + } + + /** Is this a {@code generative-nvidia} provider? */ + default boolean isNvidia() { + return _is(Generative.Kind.NVIDIA); + } + + /** + * Get as {@link NvidiaGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-nvidia}. + */ + default NvidiaGenerative asNvidia() { + return _as(Generative.Kind.NVIDIA); + } + + /** Is this a {@code generative-ollama} provider? */ + default boolean isOllama() { + return _is(Generative.Kind.OLLAMA); + } + + /** + * Get as {@link OllamaGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-ollama}. + */ + default OllamaGenerative asOllama() { + return _as(Generative.Kind.OLLAMA); + } + + /** Is this a {@code generative-openai} provider? */ + default boolean isOpenAi() { + return _is(Generative.Kind.OPENAI); + } + + /** + * Get as {@link OpenAiGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-openai}. + */ + default OpenAiGenerative asOpenAi() { + return _as(Generative.Kind.OPENAI); + } + + /** Is this an Azure-specific {@code generative-openai} provider? */ + default boolean isAzure() { + return _is(Generative.Kind.AZURE_OPENAI); + } + + /** + * Get as {@link AzureOpenAiGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-openai}. + */ + default AzureOpenAiGenerative asAzure() { + return _as(Generative.Kind.AZURE_OPENAI); + } + + /** Is this a {@code generative-xai} provider? */ + default boolean isXai() { + return _is(Generative.Kind.XAI); + } + + /** + * Get as {@link XaiGenerative} instance. + * + * @throws IllegalStateException if the current kind is not + * {@code generative-xai}. + */ + default XaiGenerative asXai() { + return _as(Generative.Kind.XAI); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> readAdapters = new EnumMap<>( + Generative.Kind.class); + + private final void addAdapter(Gson gson, Generative.Kind kind, Class cls) { + readAdapters.put(kind, (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, Generative.Kind.ANYSCALE, AnyscaleGenerative.class); + addAdapter(gson, Generative.Kind.ANTHROPIC, AnthropicGenerative.class); + addAdapter(gson, Generative.Kind.AWS, AwsGenerative.class); + addAdapter(gson, Generative.Kind.COHERE, CohereGenerative.class); + addAdapter(gson, Generative.Kind.DATABRICKS, DatabricksGenerative.class); + addAdapter(gson, Generative.Kind.GOOGLE, GoogleGenerative.class); + addAdapter(gson, Generative.Kind.FRIENDLIAI, FriendliaiGenerative.class); + addAdapter(gson, Generative.Kind.MISTRAL, MistralGenerative.class); + addAdapter(gson, Generative.Kind.NVIDIA, NvidiaGenerative.class); + addAdapter(gson, Generative.Kind.OLLAMA, OllamaGenerative.class); + addAdapter(gson, Generative.Kind.OPENAI, OpenAiGenerative.class); + addAdapter(gson, Generative.Kind.AZURE_OPENAI, AzureOpenAiGenerative.class); + addAdapter(gson, Generative.Kind.XAI, XaiGenerative.class); + addAdapter(gson, Generative.Kind.DUMMY, DummyGenerative.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + var rawType = type.getRawType(); + if (!Generative.class.isAssignableFrom(rawType)) { + return null; + } + + if (readAdapters.isEmpty()) { + init(gson); + } + + final TypeAdapter writeAdapter = (TypeAdapter) gson.getDelegateAdapter(this, + TypeToken.get(rawType)); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Generative value) throws IOException { + out.beginObject(); + out.name(value._kind().jsonValue()); + writeAdapter.write(out, (T) value._self()); + out.endObject(); + } + + @Override + public Generative read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + var provider = jsonObject.keySet().iterator().next(); + + var generative = jsonObject.get(provider).getAsJsonObject(); + Generative.Kind kind; + if (provider.equals(Generative.Kind.OPENAI.jsonValue())) { + kind = generative.has("deploymentId") && generative.has("resourceName") + ? Generative.Kind.AZURE_OPENAI + : Generative.Kind.OPENAI; + } else { + try { + kind = Generative.Kind.valueOfJson(provider); + } catch (IllegalArgumentException e) { + return null; + } + } + var adapter = readAdapters.get(kind); + assert adapter != null : "no generative adapter for kind " + kind; + return adapter.fromJsonTree(generative); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/GeoCoordinates.java b/src/main/java/io/weaviate/client6/v1/api/collections/GeoCoordinates.java new file mode 100644 index 000000000..80e10bedc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/GeoCoordinates.java @@ -0,0 +1,8 @@ +package io.weaviate.client6.v1.api.collections; + +import com.google.gson.annotations.SerializedName; + +public record GeoCoordinates( + @SerializedName("latitude") float latitude, + @SerializedName("longitude") float longitude) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/GetConfigRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/GetConfigRequest.java new file mode 100644 index 000000000..d4c73aa58 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/GetConfigRequest.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collections; +import java.util.Optional; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; + +public record GetConfigRequest(String collectionName) { + public static final Endpoint> _ENDPOINT = OptionalEndpoint + .noBodyOptional( + request -> "GET", + request -> "/schema/" + request.collectionName, + request -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, CollectionConfig.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/InvertedIndex.java b/src/main/java/io/weaviate/client6/v1/api/collections/InvertedIndex.java new file mode 100644 index 000000000..ad2fc17f6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/InvertedIndex.java @@ -0,0 +1,215 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record InvertedIndex( + /** The frequency of cleanup operations in the HNSW vector index. */ + @SerializedName("cleanupIntervalSeconds") Integer cleanupIntervalSeconds, + /** Parameters for BM25 ranking algorithm. */ + @SerializedName("bm25") Bm25 bm25, + /** Common words which should be ignored in queries. */ + @SerializedName("stopwords") Stopwords stopwords, + /** + * If true, indexes object creation and update timestamps, + * enabling filtering by creationTimeUnix and lastUpdateTimeUnix. + */ + @SerializedName("indexTimestamps") Boolean indexTimestamps, + /** + * If true, indexes the null/non-null state of each property, + * enabling filtering for null values. + */ + @SerializedName("indexNullState") Boolean indexNulls, + /** + * If true, indexes the length of each property, + * enabling filtering by property length. + */ + @SerializedName("indexPropertyLength") Boolean indexPropertyLength, + /** If true, BlockMaxWAND optimization is used. */ + @SerializedName("usingBlockMaxWAND") Boolean useBlockMaxWAND) { + + public static InvertedIndex of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public record Bm25( + /** Free parameter for the BM25 ranking function. */ + @SerializedName("b") Float b, + /** Free parameter for the BM25 ranking function. */ + @SerializedName("k1") Float k1) { + + public static Bm25 of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Bm25(Builder builder) { + this(builder.b, builder.k1); + } + + public static class Builder implements ObjectBuilder { + private Float b; + private Float k1; + + /** Set free parameter {@code b} for the BM25 ranking function. */ + public Builder b(float b) { + this.b = b; + return this; + } + + /** Set free parameter {@code k1} for the BM25 ranking function. */ + public Builder k1(float k1) { + this.k1 = k1; + return this; + } + + @Override + public Bm25 build() { + return new Bm25(this); + } + } + } + + public record Stopwords( + /** Selected preset. */ + @SerializedName("preset") String preset, + /** Custom words added to the selected preset. */ + @SerializedName("additions") List additions, + /** Words removed from the selected preset. */ + @SerializedName("removals") List removals) { + + public static Stopwords of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Stopwords(Builder builder) { + this(builder.preset, builder.additions, builder.removals); + } + + public static class Builder implements ObjectBuilder { + private String preset; + private List additions; + private List removals; + + /** Select a preset to use for a particular language. */ + public Builder preset(String preset) { + this.preset = preset; + return this; + } + + /** Add words to the selected preset. */ + public Builder add(String... additions) { + return add(Arrays.asList(additions)); + } + + /** Add words to the selected preset. */ + public Builder add(List additions) { + this.additions.addAll(additions); + return this; + } + + /** Remove words from the selected preset. */ + public Builder remove(String... removals) { + return remove(Arrays.asList(removals)); + } + + /** Remove words from the selected preset. */ + public Builder remove(List removals) { + this.removals.addAll(removals); + return this; + } + + @Override + public Stopwords build() { + return new Stopwords(this); + } + } + } + + public InvertedIndex(Builder builder) { + this( + builder.cleanupIntervalSeconds, + builder.bm25, + builder.stopwords, + builder.indexTimestamps, + builder.indexNulls, + builder.indexPropertyLength, + builder.useBlockMaxWAND); + } + + public static class Builder implements ObjectBuilder { + private Integer cleanupIntervalSeconds; + private Bm25 bm25; + private Stopwords stopwords; + private Boolean indexTimestamps; + private Boolean indexNulls; + private Boolean indexPropertyLength; + private Boolean useBlockMaxWAND; + + /** Set the frequency of cleanup operations in the HNSW vector index. */ + public Builder cleanupIntervalSeconds(int cleanupIntervalSeconds) { + this.cleanupIntervalSeconds = cleanupIntervalSeconds; + return this; + } + + /** Set {@code b} and {@code k1} parameters for BM25 ranking algorithm. */ + public Builder bm25(Function> fn) { + this.bm25 = Bm25.of(fn); + return this; + } + + /** Select and configure a stopwords preset. */ + public Builder stopwords(Function> fn) { + this.stopwords = Stopwords.of(fn); + return this; + } + + /** + * Enable / disable creating an index for creation / update timestamps. + * + * @see InvertedIndex#indexTimestamps + */ + public Builder indexTimestamps(boolean indexTimestamps) { + this.indexTimestamps = indexTimestamps; + return this; + } + + /** + * Enable / disable creating an index for null property values. + * + * @see InvertedIndex#indexNulls + */ + public Builder indexNulls(boolean indexNulls) { + this.indexNulls = indexNulls; + return this; + } + + /** + * Enable / disable creating an index for property lengths. + * + * @see InvertedIndex#indexPropertyLength + */ + public Builder indexPropertyLength(boolean indexPropertyLength) { + this.indexPropertyLength = indexPropertyLength; + return this; + } + + /** + * If true, indexes object creation and update timestamps, + * enabling filtering by creationTimeUnix and lastUpdateTimeUnix. + */ + public Builder useBlockMaxWAND(boolean useBlockMaxWAND) { + this.useBlockMaxWAND = useBlockMaxWAND; + return this; + } + + @Override + public InvertedIndex build() { + return new InvertedIndex(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionRequest.java new file mode 100644 index 000000000..9cc6f87e8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Collections; +import java.util.List; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListCollectionRequest() { + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + request -> "GET", + request -> "/schema", + request -> Collections.emptyMap(), + (gson, response) -> JSON.deserialize(response, ListCollectionResponse.class).collections()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionResponse.java new file mode 100644 index 000000000..5044431e1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/ListCollectionResponse.java @@ -0,0 +1,8 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ListCollectionResponse(@SerializedName("classes") List collections) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java b/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java new file mode 100644 index 000000000..11227eeea --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java @@ -0,0 +1,56 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record MultiTenancy( + /** Is multi-tenancy enabled for this collection. */ + @SerializedName("enabled") boolean enabled, + /** Is auto tenant creation enabled for this collection. */ + @SerializedName("autoTenantCreation") Boolean createAutomatically, + /** Is auto tenant activation enabled for this collection. */ + @SerializedName("autoTenantActivation") Boolean activateAutomatically) { + + public static MultiTenancy of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public MultiTenancy(Builder builder) { + this( + builder.enabled, + builder.createAutomatically, + builder.activateAutomatically); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Boolean createAutomatically; + private Boolean activateAutomatically; + + /** Enable / disable multi-tenancy for this collection. */ + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + /** Enable / disable auto tenant creation. */ + public Builder autoTenantCreation(boolean enabled) { + this.createAutomatically = enabled; + return this; + } + + /** Enable / disable auto tenant activation. */ + public Builder autoTenantActivation(boolean enabled) { + this.activateAutomatically = enabled; + return this; + } + + @Override + public MultiTenancy build() { + return new MultiTenancy(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/ObjectTtl.java b/src/main/java/io/weaviate/client6/v1/api/collections/ObjectTtl.java new file mode 100644 index 000000000..f8544edf4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/ObjectTtl.java @@ -0,0 +1,81 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.query.BaseQueryOptions; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record ObjectTtl( + @SerializedName("enabled") boolean enabled, + @SerializedName("defaultTtl") Integer defaultTtlSeconds, + @SerializedName("deleteOn") String deleteOn, + @SerializedName("filterExpiredObjects") Boolean filterExpiredObjects) { + + public static ObjectTtl of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public ObjectTtl(Builder builder) { + this( + builder.enabled, + builder.defaultTtlSeconds, + builder.deleteOn, + builder.filterExpiredObjects); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer defaultTtlSeconds; + private String deleteOn; + private Boolean filterExpiredObjects; + + /** Enable / disable object TTL for this collection. */ + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + /** Default TTL for all objects in this collection. */ + public Builder defaultTtlSeconds(int seconds) { + this.defaultTtlSeconds = seconds; + return this; + } + + /** + * If enabled, excludes expired objects from search results. + * Expired objects may be temporarily present until the next deletion cycle. + */ + public Builder filterExpiredObjects(boolean enabled) { + this.filterExpiredObjects = enabled; + return this; + } + + /** + * Measure TTL relative an arbitrary {@link DataType#DATE} + * property on the object. + */ + public Builder deleteByDateProperty(String property) { + this.deleteOn = property; + return this; + } + + /** Measure TTL relative to objects' creation time. */ + public Builder deleteByCreationTime() { + this.deleteOn = BaseQueryOptions.CREATION_TIME_PROPERTY; + return this; + } + + /** Measure TTL relative to objects' last update time. */ + public Builder deleteByUpdateTime() { + this.deleteOn = BaseQueryOptions.LAST_UPDATE_TIME_PROPERTY; + return this; + } + + @Override + public ObjectTtl build() { + return new ObjectTtl(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/PhoneNumber.java b/src/main/java/io/weaviate/client6/v1/api/collections/PhoneNumber.java new file mode 100644 index 000000000..3e9f5eb32 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/PhoneNumber.java @@ -0,0 +1,59 @@ +package io.weaviate.client6.v1.api.collections; + +import com.google.gson.annotations.SerializedName; + +public record PhoneNumber( + /** Raw input data provided at creation. */ + @SerializedName("input") String rawInput, + /** + * ISO 3166-1 alpha-2 country code. Required only if the raw input does not + * include an explicit country code, e.g. {@code +31}. Only present if provided + * by user. + */ + @SerializedName("defaultCountry") String defaultCountry, + /** Numerical country code. Returned by Weaviate on read. */ + @SerializedName("countryCode") Integer countryCode, + /** + * Phone number with numerical country code prepended. + * Returned by Weaviate on read. + */ + @SerializedName("internationalFormatted") String internationalFormatted, + /** + * Numerical representation of the national number. + * Returned by Weaviate on read. + */ + @SerializedName("national") Integer national, + /** + * Formatted national number. + * Returned by Weaviate on read. + */ + @SerializedName("nationalFormatted") String nationalFormatted, + /** + * Whether the server recognized this number as valid. + * Returned by Weaviate on read. + */ + @SerializedName("valid") Boolean valid) { + + /** + * Create national phone number (without explicit country code), + * e.g. {@code "020 1234567"} + * + * @param country ISO 3166-1 alpha-2 country code. + * @param phoneNumber Phone number. + * @return PhoneNumber + */ + public static PhoneNumber national(String country, String phoneNumber) { + return new PhoneNumber(phoneNumber, country, null, null, null, null, null); + } + + /** + * Create a phone number with explicit country code, + * e.g. {@code "+31 20 1234567"} + * + * @param phoneNumber Phone number. + * @return PhoneNumber + */ + public static PhoneNumber international(String phoneNumber) { + return new PhoneNumber(phoneNumber, null, null, null, null, null, null); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Property.java b/src/main/java/io/weaviate/client6/v1/api/collections/Property.java new file mode 100644 index 000000000..039e819f2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Property.java @@ -0,0 +1,612 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Property( + @SerializedName("name") String propertyName, + @SerializedName("dataType") List dataTypes, + @SerializedName("description") String description, + @SerializedName("indexInverted") Boolean indexInverted, + @SerializedName("indexFilterable") Boolean indexFilterable, + @SerializedName("indexRangeFilters") Boolean indexRangeFilters, + @SerializedName("indexSearchable") Boolean indexSearchable, + @SerializedName("tokenization") Tokenization tokenization, + @SerializedName("skipVectorization") Boolean skipVectorization, + @SerializedName("vectorizePropertyName") Boolean vectorizePropertyName, + @SerializedName("nestedProperties") List nestedProperties) { + + /** + * Create a {@code text} property. + * + * @param name Property name. + */ + public static Property text(String name) { + return text(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code text} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property text(String name, Function> fn) { + return newProperty(name, DataType.TEXT, fn); + } + + /** + * Create a {@code text} property. + * + * @param name Property name. + */ + public static Property textArray(String name) { + return textArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code text[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property textArray(String name, Function> fn) { + return newProperty(name, DataType.TEXT_ARRAY, fn); + } + + /** + * Create a {@code int} property. + * + * @param name Property name. + */ + public static Property integer(String name) { + return integer(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code int} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property integer(String name, Function> fn) { + return newProperty(name, DataType.INT, fn); + } + + /** + * Create a {@code int[]} property. + * + * @param name Property name. + */ + public static Property integerArray(String name) { + return integerArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code int[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property integerArray(String name, Function> fn) { + return newProperty(name, DataType.INT_ARRAY, fn); + } + + /** + * Create a {@code blob} property. + * + * @param name Property name. + */ + public static Property blob(String name) { + return blob(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code blob} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property blob(String name, Function> fn) { + return newProperty(name, DataType.BLOB, fn); + } + + /** + * Create a {@code bool} property. + * + * @param name Property name. + */ + public static Property bool(String name) { + return bool(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code bool} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + + public static Property bool(String name, Function> fn) { + return newProperty(name, DataType.BOOL, fn); + } + + /** + * Create a {@code bool[]} property. + * + * @param name Property name. + */ + public static Property boolArray(String name) { + return boolArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code bool[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property boolArray(String name, Function> fn) { + return newProperty(name, DataType.BOOL_ARRAY, fn); + } + + /** + * Create a {@code date} property. + * + * @param name Property name. + */ + public static Property date(String name) { + return date(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code date} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property date(String name, Function> fn) { + return newProperty(name, DataType.DATE, fn); + } + + /** + * Create a {@code date[]} property. + * + * @param name Property name. + */ + public static Property dateArray(String name) { + return dateArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code date[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property dateArray(String name, Function> fn) { + return newProperty(name, DataType.DATE_ARRAY, fn); + } + + /** + * Create a {@code uuid} property. + * + * @param name Property name. + */ + public static Property uuid(String name) { + return uuid(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code uuid} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property uuid(String name, Function> fn) { + return newProperty(name, DataType.UUID, fn); + } + + /** + * Create a {@code uuid[]} property. + * + * @param name Property name. + */ + public static Property uuidArray(String name) { + return uuidArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code uuid[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property uuidArray(String name, Function> fn) { + return newProperty(name, DataType.UUID_ARRAY, fn); + } + + /** + * Create a {@code number} property. + * + * @param name Property name. + */ + public static Property number(String name) { + return number(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code number} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property number(String name, Function> fn) { + return newProperty(name, DataType.NUMBER, fn); + } + + /** + * Create a {@code number[]} property. + * + * @param name Property name. + */ + public static Property numberArray(String name) { + return numberArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code number[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property numberArray(String name, Function> fn) { + return newProperty(name, DataType.NUMBER_ARRAY, fn); + } + + /** + * Create a {@code object} property. + * + * @param name Property name. + */ + public static Property object(String name) { + return object(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code object} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property object(String name, Function> fn) { + return newProperty(name, DataType.OBJECT, fn); + } + + /** + * Create a {@code object[]} property. + * + * @param name Property name. + */ + public static Property objectArray(String name) { + return objectArray(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code object[]} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property objectArray(String name, Function> fn) { + return newProperty(name, DataType.OBJECT_ARRAY, fn); + } + + /** + * Create a {@code phoneNumber} property. + * + * @param name Property name. + */ + public static Property phoneNumber(String name) { + return phoneNumber(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code phoneNumber} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property phoneNumber(String name, Function> fn) { + return newProperty(name, DataType.PHONE_NUMBER, fn); + } + + /** + * Create a {@code geoCoordinates} property. + * + * @param name Property name. + */ + public static Property geoCoordinates(String name) { + return geoCoordinates(name, ObjectBuilder.identity()); + } + + /** + * Create a {@code geoCoordinates} property with additional configuration. + * + * @param name Property name. + * @param fn Lambda expression for optional parameters. + */ + public static Property geoCoordinates(String name, Function> fn) { + return newProperty(name, DataType.GEO_COORDINATES, fn); + } + + private static Property newProperty(String name, String dataType, Function> fn) { + return fn.apply(new Builder(name, dataType)).build(); + } + + /** + * Create a new "edit" builder from the property configuration. Consult the documentation + * to see which configuration is mutable before updating it. + * + * Example: Update property description. + * + *

{@code
+   * Property updated = propertyHeight.edit()
+   *     .description("How tall this building is.")
+   *     .build();
+   * }
+ * + * @see #edit(Function) + */ + public Builder edit() { + return new Builder(propertyName, dataTypes) + .description(description) + .indexInverted(indexInverted) + .indexFilterable(indexFilterable) + .indexRangeFilters(indexRangeFilters) + .indexSearchable(indexSearchable) + .tokenization(tokenization) + .skipVectorization(skipVectorization) + .vectorizePropertyName(vectorizePropertyName); + } + + /** + * Pass a lambda expression to update property configuration. Consult the documentation + * to see which configuration is mutable before updating it. + * + * Example: Update property description. + * + *
{@code
+   * Property updated = propertyHeight.edit(
+   *     p -> p.description("How tall this building is."));
+   * }
+ * + * @see #edit() + */ + public Property edit(Function> fn) { + return fn.apply(edit()).build(); + } + + public Property(Builder builder) { + this( + builder.propertyName, + builder.dataTypes, + builder.description, + builder.indexInverted, + builder.indexFilterable, + builder.indexRangeFilters, + builder.indexSearchable, + builder.tokenization, + builder.skipVectorization, + builder.vectorizePropertyName, + builder.nestedProperties.isEmpty() ? null : builder.nestedProperties); + } + + // All methods accepting a `boolean` should have a boxed overload + // to be used by Property::edit. + // + // There we can't just do: + // .indexInverted(indexInverted == null ? false : indexInverted) + // because that may change the value from `null` to Boolean.FALSE, + // effectively updating this setting. In the context of PUT /schema/{collection} + // call this becomes a problem because we're not allowed to update anything + // except for the description. + // + // The alternative (wrapping each call in an if-block) seems too verbose. + public static class Builder implements ObjectBuilder { + // Required parameters. + private final String propertyName; + private final List dataTypes = new ArrayList<>(); + + // Optional parameters. + private String description; + private Boolean indexInverted; + private Boolean indexFilterable; + private Boolean indexRangeFilters; + private Boolean indexSearchable; + private Tokenization tokenization; + private Boolean skipVectorization; + private Boolean vectorizePropertyName; + private List nestedProperties = new ArrayList<>(); + + /** + * Create a scalar / array type property. + * + * @param dataType Property data type, see {@link DataType}. + */ + public Builder(String propertyName, String dataType) { + this.propertyName = propertyName; + this.dataTypes.add(dataType); + } + + /** + * Create a cross-reference property. + * + * @param dataTypes List of collection names this property can reference. + */ + public Builder(String propertyName, List dataTypes) { + this.propertyName = propertyName; + this.dataTypes.addAll(dataTypes); + } + + /** Add property description. */ + public Builder description(String description) { + this.description = description; + return this; + } + + public Builder indexInverted(boolean indexInverted) { + this.indexInverted = indexInverted; + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder indexInverted(Boolean indexInverted) { + this.indexInverted = indexInverted; + return this; + } + + /** + * Set to true to create a filtering index for this property. + * + *

+ * Filterable indices are not applicable to {@code blob}, {@code object}, + * {@code geoCoordinates}, and {@code phoneNumber} properties or arrays thereof. + * + * @see Inverted + * Indexes + */ + public Builder indexFilterable(boolean indexFilterable) { + this.indexFilterable = indexFilterable; + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder indexFilterable(Boolean indexFilterable) { + this.indexFilterable = indexFilterable; + return this; + } + + /** + * Set to true to create a range-based filter for filtering + * by numerical ranges for this property. + * + *

+ * Applicable to {code int}, {@code number}, and {@code date} properties. + * + * @see Inverted + * Indexes + */ + public Builder indexRangeFilters(boolean indexRangeFilters) { + this.indexRangeFilters = indexRangeFilters; + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder indexRangeFilters(Boolean indexRangeFilters) { + this.indexRangeFilters = indexRangeFilters; + return this; + } + + /** + * Set to true to create a searchable index for this property. + * + *

+ * This index type enables BM25/hybrid search and is only applicable to + * {@code text}/{@code text[]} fields. For those it is also created + * by default; you should set {@code indexInverted(false)} if you + * do not plan to run BM25/hybrid queries on this property. + * + * @see Inverted + * Indexes + */ + public Builder indexSearchable(boolean indexSearchable) { + this.indexSearchable = indexSearchable; + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder indexSearchable(Boolean indexSearchable) { + this.indexSearchable = indexSearchable; + return this; + } + + /** + * Change tokenization method for this property. + * + * @see Tokenization + */ + public Builder tokenization(Tokenization tokenization) { + this.tokenization = tokenization; + return this; + } + + public Builder skipVectorization(boolean skipVectorization) { + this.skipVectorization = skipVectorization; + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder skipVectorization(Boolean skipVectorization) { + this.skipVectorization = skipVectorization; + return this; + } + + /** Include property name into the input for the vectorizer module. */ + public Builder vectorizePropertyName(boolean vectorizePropertyName) { + this.vectorizePropertyName = vectorizePropertyName; + return this; + } + + /** + * Defined nested properties. This configuration is only applicable to a + * property of type {@code object} and {@code object[]}. + * + *

{@code
+     * Property.object("address",
+     *     p -> p.nestedProperties(
+     *         Property.text("street"),
+     *         Property.integer("building_nr")))
+     * }
+ */ + public Builder nestedProperties(Property... properties) { + return nestedProperties(Arrays.asList(properties)); + } + + /** + * Defined nested properties. This configuration is only applicable to a + * property of type {@code object} and {@code object[]}. + * + * @see Builder#nestedProperties(Property...) + */ + public Builder nestedProperties(List properties) { + this.nestedProperties.addAll(properties); + return this; + } + + /** Convenience method to be used by {@link Property#edit}. */ + Builder vectorizePropertyName(Boolean vectorizePropertyName) { + this.vectorizePropertyName = vectorizePropertyName; + return this; + } + + @Override + public Property build() { + return new Property(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Quantization.java b/src/main/java/io/weaviate/client6/v1/api/collections/Quantization.java new file mode 100644 index 000000000..c60a67c43 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Quantization.java @@ -0,0 +1,221 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.quantizers.BQ; +import io.weaviate.client6.v1.api.collections.quantizers.PQ; +import io.weaviate.client6.v1.api.collections.quantizers.RQ; +import io.weaviate.client6.v1.api.collections.quantizers.SQ; +import io.weaviate.client6.v1.api.collections.quantizers.Uncompressed; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.TaggedUnion; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface Quantization extends TaggedUnion { + + public enum Kind implements JsonEnum { + UNCOMPRESSED("skipDefaultQuantization"), + RQ("rq"), + BQ("bq"), + PQ("pq"), + SQ("sq"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + Kind _kind(); + + Object _self(); + + /** Disable any quantization for this collection. */ + public static Quantization uncompressed() { + return Uncompressed.of(); + } + + /** Enable binary quantization for this collection. */ + public static Quantization bq() { + return BQ.of(); + } + + /** + * Enable binary quantization for this collection. + * + * @param fn Lambda expression for optional parameters. + */ + public static Quantization bq(Function> fn) { + return BQ.of(fn); + } + + /** Enable product quantization for this collection. */ + public static Quantization pq() { + return PQ.of(); + } + + /** + * Enable product quantization for this collection. + * + * @param fn Lambda expression for optional parameters. + */ + public static Quantization pq(Function> fn) { + return PQ.of(fn); + } + + /** Enable scalar quantization for this collection. */ + public static Quantization sq() { + return SQ.of(); + } + + /** + * Enable scalar quantization for this collection. + * + * @param fn Lambda expression for optional parameters. + */ + public static Quantization sq(Function> fn) { + return SQ.of(fn); + } + + /** Enable rotational quantization for this collection. */ + public static Quantization rq() { + return RQ.of(); + } + + /** + * Enable rotational quantization for this collection. + * + * @param fn Lambda expression for optional parameters. + */ + public static Quantization rq(Function> fn) { + return RQ.of(fn); + } + + default BQ asBQ() { + return _as(Quantization.Kind.BQ); + } + + default RQ asRQ() { + return _as(Quantization.Kind.RQ); + } + + default PQ asPQ() { + return _as(Quantization.Kind.PQ); + } + + default SQ asSQ() { + return _as(Quantization.Kind.SQ); + } + + default Uncompressed asUncompressed() { + return _as(Quantization.Kind.UNCOMPRESSED); + } + + default boolean isBQ() { + return _is(Quantization.Kind.BQ); + } + + default boolean isRQ() { + return _is(Quantization.Kind.RQ); + } + + default boolean isPQ() { + return _is(Quantization.Kind.PQ); + } + + default boolean isSQ() { + return _is(Quantization.Kind.SQ); + } + + default boolean isUncompressed() { + return _is(Quantization.Kind.UNCOMPRESSED); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> delegateAdapters = new EnumMap<>( + Quantization.Kind.class); + + private final void addAdapter(Gson gson, Quantization.Kind kind, Class cls) { + delegateAdapters.put(kind, + (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, Quantization.Kind.UNCOMPRESSED, Uncompressed.class); + addAdapter(gson, Quantization.Kind.BQ, BQ.class); + addAdapter(gson, Quantization.Kind.RQ, RQ.class); + addAdapter(gson, Quantization.Kind.SQ, SQ.class); + addAdapter(gson, Quantization.Kind.PQ, PQ.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + final var rawType = type.getRawType(); + if (!Quantization.class.isAssignableFrom(rawType)) { + return null; + } + + if (delegateAdapters.isEmpty()) { + init(gson); + } + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Quantization value) throws IOException { + if (value._kind() == Quantization.Kind.UNCOMPRESSED) { + out.value(true); + return; + } + TypeAdapter adapter = (TypeAdapter) delegateAdapters.get(value._kind()); + adapter.write(out, (T) value._self()); + } + + @Override + public Quantization read(JsonReader in) throws IOException { + var quantizerObject = JsonParser.parseReader(in).getAsJsonObject(); + var quantizationName = quantizerObject.keySet().iterator().next(); + Quantization.Kind kind; + try { + kind = Quantization.Kind.valueOfJson(quantizationName); + } catch (IllegalArgumentException e) { + return null; + } + + if (kind == Quantization.Kind.UNCOMPRESSED) { + return new Uncompressed(); + } + + var adapter = delegateAdapters.get(kind); + var concreteQuantizer = quantizerObject.get(quantizationName).getAsJsonObject(); + return adapter.fromJsonTree(concreteQuantizer); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Reference.java b/src/main/java/io/weaviate/client6/v1/api/collections/Reference.java new file mode 100644 index 000000000..09576f08a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Reference.java @@ -0,0 +1,41 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Map; + +import io.weaviate.client6.v1.api.collections.data.ObjectReference; + +public interface Reference { + /** UUID of the reference object. */ + String uuid(); + + /** Name of the collection the reference belongs to. */ + String collection(); + + /** + * Cast {@code this} into an instance of {@link WeaviateObject>}. Useful when working with references retrieved in a query. + * + *
{@code
+   *  var metalSongs = songs.query.fetchObjects(q -> q
+   *    .filters(Filter.property("genres").containsAll("metal")
+   *    .returnReferences(QueryReference.multi("performedBy"));
+   *
+   *  metalSongs.objects().forEach(song -> {
+   *    var songName = song.properties().get("name");
+   *    song.references().forEach(ref -> {
+   *      var artistName = ref.asWeaviateObject().properties().get("artistName");
+   *      System.out.printf("%s is performed by %s", songName, artistName);
+   *    });
+   *  });
+   * }
+ * + *

+ * Only call this method on objects returned from methods under {@code .query} + * namespace, as insert-references do not implement this interface. + * + * @throws IllegalStateException if reference object is an instance of + * {@link ObjectReference}. See usage guidelines + * above. + */ + WeaviateObject> asWeaviateObject(); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/ReferenceProperty.java b/src/main/java/io/weaviate/client6/v1/api/collections/ReferenceProperty.java new file mode 100644 index 000000000..7b3d37703 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/ReferenceProperty.java @@ -0,0 +1,51 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ReferenceProperty( + @SerializedName("name") String propertyName, + @SerializedName("dataType") List dataTypes) { + + /** + * Create a cross-reference to another collection. + * + *

{@code
+   * // Single-target reference
+   * ReferenceProperty.to("livesIn", "Cities");
+   *
+   * // Multi-reference
+   * ReferenceProperty.to("hasSeen", "Movies", "Plays", "SoapOperas");
+   * }
+ * + * @param name Name of the property. + * @param collections One or more collections which can be referenced. + * @return ReferenceProperty + */ + public static ReferenceProperty to(String name, String... collections) { + return new ReferenceProperty(name, Arrays.asList(collections)); + } + + /** + * Create a multi-target reference property. + * + *
{@code
+   * List thingsToSee = List.of("Movies", "Plays", "SoapOperas");
+   * ReferenceProperty.to("hasSeen", thingsToSee);
+   * }
+ * + * @param name Name of the property. + * @param collections One or more collections which can be referenced. + * @return ReferenceProperty + */ + public static ReferenceProperty to(String name, List collections) { + return new ReferenceProperty(name, collections); + } + + /** This method is intended for client's internal use only. */ + public Property toProperty() { + return new Property.Builder(propertyName, dataTypes).build(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Replication.java b/src/main/java/io/weaviate/client6/v1/api/collections/Replication.java new file mode 100644 index 000000000..a01af272c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Replication.java @@ -0,0 +1,65 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Replication( + @SerializedName("factor") Integer replicationFactor, + @SerializedName("asyncEnabled") Boolean asyncEnabled, + @SerializedName("deletionStrategy") DeletionStrategy deletionStrategy) { + + public static enum DeletionStrategy { + @SerializedName("NoAutomatedResolution") + NO_AUTOMATED_RESOLUTION, + @SerializedName("DeleteOnConflict") + DELETE_ON_CONFLICT, + @SerializedName("TimeBasedResolution") + TIME_BASED_RESOLUTION; + } + + public static Replication of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Replication(Builder builder) { + this( + builder.replicationFactor, + builder.asyncEnabled, + builder.deletionStrategy); + } + + public static class Builder implements ObjectBuilder { + private Integer replicationFactor; + private Boolean asyncEnabled; + private DeletionStrategy deletionStrategy; + + /** Set desired replication factor for this collection. */ + public Builder replicationFactor(int replicationFactor) { + this.replicationFactor = replicationFactor; + return this; + } + + /** Enable / disable async replication. */ + public Builder asyncEnabled(boolean asyncEnabled) { + this.asyncEnabled = asyncEnabled; + return this; + } + + /** + * Select the deletion strategy for resolving conflicts + * during async replication. + */ + public Builder deletionStrategy(DeletionStrategy deletionStrategy) { + this.deletionStrategy = deletionStrategy; + return this; + } + + @Override + public Replication build() { + return new Replication(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Reranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/Reranker.java new file mode 100644 index 000000000..5f38fc31e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Reranker.java @@ -0,0 +1,175 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonToken; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.rerankers.CohereReranker; +import io.weaviate.client6.v1.api.collections.rerankers.DummyReranker; +import io.weaviate.client6.v1.api.collections.rerankers.JinaAiReranker; +import io.weaviate.client6.v1.api.collections.rerankers.NvidiaReranker; +import io.weaviate.client6.v1.api.collections.rerankers.TransformersReranker; +import io.weaviate.client6.v1.api.collections.rerankers.VoyageAiReranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.TaggedUnion; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface Reranker extends TaggedUnion { + public enum Kind implements JsonEnum { + DUMMY("reranker-dummy"), + JINAAI("reranker-jinaai"), + VOYAGEAI("reranker-voyageai"), + NVIDIA("reranker-nvidia"), + TRANSFORMERS("reranker-transformers"), + COHERE("reranker-cohere"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + /** Configure a default Cohere reranker module. */ + public static Reranker cohere() { + return CohereReranker.of(); + } + + /** + * Configure a Cohere reranker module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Reranker cohere(Function> fn) { + return CohereReranker.of(fn); + } + + /** Configure a default JinaAI reranker module. */ + public static Reranker jinaai() { + return JinaAiReranker.of(); + } + + /** + * Configure a JinaAI reranker module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Reranker jinaai(Function> fn) { + return JinaAiReranker.of(fn); + } + + /** Configure a default VoyageAI reranker module. */ + public static Reranker voyageai() { + return VoyageAiReranker.of(); + } + + /** + * Configure a VoyageAI reranker module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Reranker voyageai(Function> fn) { + return VoyageAiReranker.of(fn); + } + + /** Configure a default Nvidia reranker module. */ + public static Reranker nvidia() { + return NvidiaReranker.of(); + } + + /** + * Configure a Nvidia reranker module. + * + * @param fn Lambda expression for optional parameters. + */ + public static Reranker nvidia(Function> fn) { + return NvidiaReranker.of(fn); + } + + /** Configure a default Transformers reranker module. */ + public static Reranker transformers() { + return new TransformersReranker(); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> readAdapters = new EnumMap<>( + Reranker.Kind.class); + + private final void addAdapter(Gson gson, Reranker.Kind kind, Class cls) { + readAdapters.put(kind, (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, Reranker.Kind.COHERE, CohereReranker.class); + addAdapter(gson, Reranker.Kind.JINAAI, JinaAiReranker.class); + addAdapter(gson, Reranker.Kind.NVIDIA, NvidiaReranker.class); + addAdapter(gson, Reranker.Kind.TRANSFORMERS, TransformersReranker.class); + addAdapter(gson, Reranker.Kind.VOYAGEAI, VoyageAiReranker.class); + addAdapter(gson, Reranker.Kind.DUMMY, DummyReranker.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + var rawType = type.getRawType(); + if (!Reranker.class.isAssignableFrom(rawType)) { + return null; + } + + if (readAdapters.isEmpty()) { + init(gson); + } + + final TypeAdapter writeAdapter = (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(rawType)); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Reranker value) throws IOException { + out.beginObject(); + out.name(value._kind().jsonValue()); + writeAdapter.write(out, (T) value._self()); + out.endObject(); + } + + @Override + public Reranker read(JsonReader in) throws IOException { + in.beginObject(); + var rerankerName = in.nextName(); + try { + var kind = Reranker.Kind.valueOfJson(rerankerName); + var adapter = readAdapters.get(kind); + return adapter.read(in); + } catch (IllegalArgumentException e) { + return null; + } finally { + if (in.peek() == JsonToken.BEGIN_OBJECT) { + in.beginObject(); + } + in.endObject(); + } + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Sharding.java b/src/main/java/io/weaviate/client6/v1/api/collections/Sharding.java new file mode 100644 index 000000000..f2a853a82 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Sharding.java @@ -0,0 +1,50 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Sharding( + @SerializedName("virtualPerPhysical") Integer virtualPerPhysical, + @SerializedName("desiredCount") Integer desiredCount, + @SerializedName("desiredVirtualCount") Integer desiredVirtualCount) { + + public static Sharding of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Sharding(Builder builder) { + this( + builder.virtualPerPhysical, + builder.desiredCount, + builder.desiredVirtualCount); + } + + public static class Builder implements ObjectBuilder { + private Integer virtualPerPhysical; + private Integer desiredCount; + private Integer desiredVirtualCount; + + public Builder virtualPerPhysical(int virtualPerPhysical) { + this.virtualPerPhysical = virtualPerPhysical; + return this; + } + + public Builder desiredCount(int desiredCount) { + this.desiredCount = desiredCount; + return this; + } + + public Builder desiredVirtualCount(int desiredVirtualCount) { + this.desiredVirtualCount = desiredVirtualCount; + return this; + } + + @Override + public Sharding build() { + return new Sharding(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Tokenization.java b/src/main/java/io/weaviate/client6/v1/api/collections/Tokenization.java new file mode 100644 index 000000000..5ae790571 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Tokenization.java @@ -0,0 +1,23 @@ +package io.weaviate.client6.v1.api.collections; + +import com.google.gson.annotations.SerializedName; + +/** Tokenization methods available within Weaviate. */ +public enum Tokenization { + @SerializedName("word") + WORD, + @SerializedName("whitespace") + WHITESPACE, + @SerializedName("lowercase") + LOWERCASE, + @SerializedName("field") + FIELD, + @SerializedName("gse") + GSE, + @SerializedName("trigram") + TRIGRAM, + @SerializedName("kagome_ja") + KAGOME_JA, + @SerializedName("kagome_kr") + KAGOME_KR; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/VectorConfig.java b/src/main/java/io/weaviate/client6/v1/api/collections/VectorConfig.java new file mode 100644 index 000000000..045313a16 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/VectorConfig.java @@ -0,0 +1,1668 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.vectorizers.Img2VecNeuralVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2MultiVecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecAwsVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecBindVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecClipVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecCohereVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecGoogleVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecNvidiaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecVoyageAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Ref2VecCentroidVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.SelfProvidedVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2MultiVecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecAwsVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecAzureOpenAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecCohereVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecDatabricksVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecGoogleVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecHuggingFaceVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecMistralVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecModel2VecVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecMorphVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecNvidiaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecOllamaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecOpenAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecTransformersVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecVoyageAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecWeaviateVectorizer; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.TaggedUnion; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface VectorConfig extends TaggedUnion { + public enum Kind implements JsonEnum { + NONE("none"), + TEXT2VEC_AWS("text2vec-aws"), + TEXT2VEC_COHERE("text2vec-cohere"), + TEXT2VEC_DATABRICKS("text2vec-databricks"), + TEXT2VEC_GOOGLE("text2vec-google"), + TEXT2VEC_HUGGINGFACE("text2vec-huggingface"), + REF2VEC_CENTROID("ref2vec-centroid"), + TEXT2VEC_JINAAI("text2vec-jinaai"), + TEXT2VEC_MISTRAL("text2vec-mistral"), + TEXT2VEC_MORPH("text2vec-morph"), + TEXT2VEC_MODEL2VEC("text2vec-model2vec"), + TEXT2VEC_NVIDIA("text2vec-nvidia"), + TEXT2VEC_OPENAI("text2vec-openai"), + TEXT2VEC_AZURE_OPENAI("text2vec-openai"), + TEXT2VEC_OLLAMA("text2vec-ollama"), + TEXT2VEC_TRANSFORMERS("text2vec-transformers"), + TEXT2VEC_VOYAGEAI("text2vec-voyageai"), + TEXT2VEC_WEAVIATE("text2vec-weaviate"), + IMG2VEC_NEURAL("img2vec-neural"), + MULTI2VEC_AWS("multi2vec-aws"), + MULTI2VEC_BIND("multi2vec-bind"), + MULTI2VEC_CLIP("multi2vec-clip"), + MULTI2VEC_GOOGLE("multi2vec-google"), + MULTI2VEC_COHERE("multi2vec-cohere"), + MULTI2VEC_JINAAI("multi2vec-jinaai"), + MULTI2VEC_NVIDIA("multi2vec-nvidia"), + MULTI2VEC_VOYAGEAI("multi2vec-voyageai"), + TEXT2MULTIVEC_JINAAI("text2multivec-jinaai"), + MULTI2MULTIVEC_JINAAI("multi2multivec-jinaai"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + /** Get vector index configuration for this vector. */ + VectorIndex vectorIndex(); + + /** Get quantization configuration for this vector. */ + Quantization quantization(); + + /** Create a bring-your-own-vector vector index. */ + public static Map.Entry selfProvided() { + return selfProvided(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a bring-your-own-vector vector index. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry selfProvided( + Function> fn) { + return selfProvided(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named bring-your-own-vector vector index. + * + * @param vectorName Vector name. + */ + public static Map.Entry selfProvided(String vectorName) { + return Map.entry(vectorName, SelfProvidedVectorizer.of()); + } + + /** + * Create a named bring-your-own-vector vector index. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry selfProvided(String vectorName, + Function> fn) { + return Map.entry(vectorName, SelfProvidedVectorizer.of(fn)); + } + + /** Create a vector index with an {@code img2vec-neural} vectorizer. */ + public static Map.Entry img2vecNeural() { + return img2vecNeural(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code img2vec-neural} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry img2vecNeural( + Function> fn) { + return img2vecNeural(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code img2vec-neural} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry img2vecNeural(String vectorName) { + return Map.entry(vectorName, Img2VecNeuralVectorizer.of()); + } + + /** + * Create a vector index with an {@code img2vec-neural} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry img2vecNeural(String vectorName, + Function> fn) { + return Map.entry(vectorName, Img2VecNeuralVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2multivec-jinaai} vectorizer. */ + public static Map.Entry multi2multivecJinaai() { + return multi2multivecJinaai(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2multivec-jinaai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2multivecJinaai( + Function> fn) { + return multi2multivecJinaai(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2multivec-jinaai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2multivecJinaai(String vectorName) { + return Map.entry(vectorName, Multi2MultiVecJinaAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2multivec-jinaai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2multivecJinaai(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2MultiVecJinaAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-aws} vectorizer. */ + public static Map.Entry multi2vecAws() { + return multi2vecAws(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-aws} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecAws( + Function> fn) { + return multi2vecAws(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-aws} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecAws(String vectorName) { + return Map.entry(vectorName, Multi2VecAwsVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-aws} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecAws(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecAwsVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-bind} vectorizer. */ + public static Map.Entry multi2vecBind() { + return multi2vecBind(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-bind} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecBind( + Function> fn) { + return multi2vecBind(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-bind} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecBind(String vectorName) { + return Map.entry(vectorName, Multi2VecBindVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-bind} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecBind(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecBindVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-clip} vectorizer. */ + public static Map.Entry multi2vecClip() { + return multi2vecClip(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-clip} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecClip( + Function> fn) { + return multi2vecClip(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-clip} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecClip(String vectorName) { + return Map.entry(vectorName, Multi2VecClipVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-clip} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecClip(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecClipVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-cohere} vectorizer. */ + public static Map.Entry multi2vecCohere() { + return multi2vecBind(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-cohere} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecCohere( + Function> fn) { + return multi2vecCohere(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-cohere} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecCohere(String vectorName) { + return Map.entry(vectorName, Multi2VecCohereVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-cohere} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecCohere(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecCohereVectorizer.of(fn)); + } + + /** + * Create a vector index with an {@code multi2vec-google} vectorizer. + * + * @param location Geographic region the Google Cloud model runs in. + */ + public static Map.Entry multi2vecGoogle(String projectId, String location) { + return multi2vecGoogle(VectorIndex.DEFAULT_VECTOR_NAME, projectId, location); + } + + /** + * Create a vector index with an {@code multi2vec-google} vectorizer. + * + * @param location Geographic region the Google Cloud model runs in. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecGoogle( + String projectId, + String location, + Function> fn) { + return multi2vecGoogle(VectorIndex.DEFAULT_VECTOR_NAME, projectId, location, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-google} vectorizer. + * + * @param vectorName Vector name. + * @param location Geographic region the Google Cloud model runs in. + */ + public static Map.Entry multi2vecGoogle(String vectorName, String projectId, String location) { + return Map.entry(vectorName, Multi2VecGoogleVectorizer.of(projectId, location)); + } + + /** + * Create a named vector index with an {@code multi2vec-google} vectorizer. + * + * @param vectorName Vector name. + * @param location Geographic region the Google Cloud model runs in. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecGoogle(String vectorName, + String projectId, String location, + Function> fn) { + return Map.entry(vectorName, Multi2VecGoogleVectorizer.of(projectId, location, fn)); + } + + /** Create a vector index with an {@code multi2vec-jinaai} vectorizer. */ + public static Map.Entry multi2vecJinaAi() { + return multi2vecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-jinaai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecJinaAi( + Function> fn) { + return multi2vecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-jinaai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecJinaAi(String vectorName) { + return Map.entry(vectorName, Multi2VecJinaAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-jinaai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecJinaAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecJinaAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-nvidia} vectorizer. */ + public static Map.Entry multi2vecNvidia() { + return multi2vecNvidia(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-nvidia} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecNvidia( + Function> fn) { + return multi2vecNvidia(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-nvidia} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecNvidia(String vectorName) { + return Map.entry(vectorName, Multi2VecNvidiaVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-nvidia} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecNvidia(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecNvidiaVectorizer.of(fn)); + } + + /** Create a vector index with an {@code multi2vec-voyageai} vectorizer. */ + public static Map.Entry multi2vecVoyageAi() { + return multi2vecVoyageAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code multi2vec-voyageai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecVoyageAi( + Function> fn) { + return multi2vecVoyageAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code multi2vec-voyageai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry multi2vecVoyageAi(String vectorName) { + return Map.entry(vectorName, Multi2VecVoyageAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code multi2vec-voyageai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry multi2vecVoyageAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Multi2VecVoyageAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code ref2vec-centroid} vectorizer. */ + public static Map.Entry ref2vecCentroid() { + return ref2vecCentroid(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code ref2vec-centroid} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry ref2vecCentroid( + Function> fn) { + return ref2vecCentroid(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code ref2vec-centroid} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry ref2vecCentroid(String vectorName) { + return Map.entry(vectorName, Ref2VecCentroidVectorizer.of()); + } + + /** + * Create a named vector index with an {@code ref2vec-centroid} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry ref2vecCentroid(String vectorName, + Function> fn) { + return Map.entry(vectorName, Ref2VecCentroidVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2multivec-jinaai} vectorizer. */ + public static Map.Entry text2multivecJinaAi() { + return text2multivecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2multivec-jinaai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2multivecJinaAi( + Function> fn) { + return text2multivecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2multivec-jinaai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2multivecJinaAi(String vectorName) { + return Map.entry(vectorName, Text2MultiVecJinaAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2multivec-jinaai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2multivecJinaAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2MultiVecJinaAiVectorizer.of(fn)); + } + + /** + * Create a vector index with an {@code text2vec-aws} vectorizer with Bedrock + * integration. + * + * @param model Inference model. + */ + public static Map.Entry text2vecAwsBedrock(String model) { + return text2vecAwsBedrock(VectorIndex.DEFAULT_VECTOR_NAME, model); + } + + /** + * Create a vector index with an {@code text2vec-aws} vectorizer with Bedrock + * integration. + * + * @param model Inference model. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAwsBedrock( + String model, + Function> fn) { + return text2vecAwsBedrock(VectorIndex.DEFAULT_VECTOR_NAME, model, fn); + } + + /** + * Create a named vector index with an {@code text2vec-aws} + * vectorizer with Bedrock integration. + * + * @param vectorName Vector name. + * @param model Inference model. + */ + public static Map.Entry text2vecAwsBedrock(String vectorName, String model) { + return Map.entry(vectorName, Text2VecAwsVectorizer.bedrock(model)); + } + + /** + * Create a named vector index with an {@code text2vec-aws} + * vectorizer with Bedrock integration. + * + * @param vectorName Vector name. + * @param model Inference model. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAwsBedrock(String vectorName, + String model, + Function> fn) { + return Map.entry(vectorName, Text2VecAwsVectorizer.bedrock(model, fn)); + } + + /** + * Create a vector index with an {@code text2vec-aws} vectorizer with Sagemaker + * integration. + * + * @param endpoint Base URL of the inference service. + */ + public static Map.Entry text2vecAwsSagemaker(String endpoint) { + return text2vecAwsSagemaker(VectorIndex.DEFAULT_VECTOR_NAME, endpoint); + } + + /** + * Create a vector index with an {@code text2vec-aws} vectorizer with Sagemaker + * integration. + * + * @param endpoint Base URL of the inference service. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAwsSagemaker( + String endpoint, + Function> fn) { + return text2vecAwsSagemaker(VectorIndex.DEFAULT_VECTOR_NAME, endpoint, fn); + } + + /** + * Create a named vector index with an {@code text2vec-aws} + * vectorizer with Sagemaker integration. + * + * @param vectorName Vector name. + * @param endpoint Base URL of the inference service. + */ + public static Map.Entry text2vecAwsSagemaker(String vectorName, String endpoint) { + return Map.entry(vectorName, Text2VecAwsVectorizer.sagemaker(endpoint)); + } + + /** + * Create a named vector index with an {@code text2vec-aws} + * vectorizer with Sagemaker integration. + * + * @param vectorName Vector name. + * @param endpoint Base URL of the inference service. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAwsSagemaker(String vectorName, + String endpoint, + Function> fn) { + return Map.entry(vectorName, Text2VecAwsVectorizer.sagemaker(endpoint, fn)); + } + + /** + * Create a vector index with an {@code text2vec-openai} vectorizer deployed on + * Azure. + */ + public static Map.Entry text2vecAzureOpenAi() { + return text2vecAzureOpenAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-openai} vectorizer deployed on + * Azure. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAzureOpenAi( + Function> fn) { + return text2vecAzureOpenAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-openai} vectorizer + * deployed on Azure. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecAzureOpenAi(String vectorName) { + return Map.entry(vectorName, Text2VecAzureOpenAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-openai} vectorizer + * deployed on Azure. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecAzureOpenAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecAzureOpenAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-cohere} vectorizer. */ + public static Map.Entry text2vecCohere() { + return text2vecCohere(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-cohere} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecCohere( + Function> fn) { + return text2vecCohere(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-cohere} + * vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecCohere(String vectorName) { + return Map.entry(vectorName, Text2VecCohereVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-cohere} + * vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecCohere(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecCohereVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-databricks} vectorizer. */ + public static Map.Entry text2vecDatabricks() { + return text2vecDatabricks(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-databricks} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecDatabricks( + Function> fn) { + return text2vecDatabricks(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-databricks} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecDatabricks(String vectorName) { + return Map.entry(vectorName, Text2VecDatabricksVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-databricks} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecDatabricks(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecDatabricksVectorizer.of(fn)); + } + + /** + * Create a vector index with an {@code text2vec-google} vectorizer with Google + * AI Studio integration. + */ + public static Map.Entry text2vecGoogleAiStudio() { + return text2vecGoogleAiStudio(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-google} vectorizer with Google + * AI Studio integration. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecGoogleAiStudio( + Function> fn) { + return text2vecGoogleAiStudio(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-google} vectorizer with + * Google AI Studio integration. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecGoogleAiStudio(String vectorName) { + return Map.entry(vectorName, Text2VecGoogleVectorizer.aiStudio()); + } + + /** + * Create a named vector index with an {@code text2vec-google} vectorizer with + * Google AI Studio integration. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecGoogleAiStudio(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecGoogleVectorizer.aiStudio(fn)); + } + + /** Create a vector index with an {@code text2vec-google} vectorizer. */ + public static Map.Entry text2vecGoogleVertex(String projectId) { + return text2vecGoogleVertex(VectorIndex.DEFAULT_VECTOR_NAME, projectId); + } + + /** + * Create a vector index with an {@code text2vec-google} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecGoogleVertex(String projectId, + Function> fn) { + return text2vecGoogleVertex(VectorIndex.DEFAULT_VECTOR_NAME, projectId, fn); + } + + /** + * Create a named vector index with an {@code text2vec-google} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecGoogleVertex(String vectorName, String projectId) { + return Map.entry(vectorName, Text2VecGoogleVectorizer.vertex(projectId)); + } + + /** + * Create a named vector index with an {@code text2vec-google} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecGoogleVertex(String vectorName, String projectId, + Function> fn) { + return Map.entry(vectorName, Text2VecGoogleVectorizer.vertex(projectId, fn)); + } + + /** Create a vector index with an {@code text2vec-huggingface} vectorizer. */ + public static Map.Entry text2vecHuggingFace() { + return text2vecHuggingFace(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-huggingface} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecHuggingFace( + Function> fn) { + return text2vecHuggingFace(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-huggingface} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecHuggingFace(String vectorName) { + return Map.entry(vectorName, Text2VecHuggingFaceVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-huggingface} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecHuggingFace(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecHuggingFaceVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-jinaai} vectorizer. */ + public static Map.Entry text2vecJinaAi() { + return text2vecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-jinaai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecJinaAi( + Function> fn) { + return text2vecJinaAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-jinaai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecJinaAi(String vectorName) { + return Map.entry(vectorName, Text2VecJinaAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-jinaai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecJinaAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecJinaAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-mistral} vectorizer. */ + public static Map.Entry text2vecMistral() { + return text2vecMistral(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-mistral} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecMistral( + Function> fn) { + return text2vecMistral(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-mistral} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecMistral(String vectorName) { + return Map.entry(vectorName, Text2VecMistralVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-mistral} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecMistral(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecMistralVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-model2vec} vectorizer. */ + public static Map.Entry text2vecModel2Vec() { + return text2vecModel2Vec(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-model2vec} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecModel2Vec( + Function> fn) { + return text2vecModel2Vec(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-model2vec} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecModel2Vec(String vectorName) { + return Map.entry(vectorName, Text2VecModel2VecVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-model2vec} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecModel2Vec(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecModel2VecVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-morph} vectorizer. */ + public static Map.Entry text2vecMorph() { + return text2vecMorph(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-morph} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecMorph( + Function> fn) { + return text2vecMorph(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-morph} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecMorph(String vectorName) { + return Map.entry(vectorName, Text2VecMorphVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-morph} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecMorph(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecMorphVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-nvidia} vectorizer. */ + public static Map.Entry text2vecNvidia() { + return text2vecNvidia(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-nvidia} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecNvidia( + Function> fn) { + return text2vecNvidia(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-nvidia} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecNvidia(String vectorName) { + return Map.entry(vectorName, Text2VecNvidiaVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-nvidia} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecNvidia(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecNvidiaVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-ollama} vectorizer. */ + public static Map.Entry text2vecOllama() { + return text2vecOllama(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-ollama} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecOllama( + Function> fn) { + return text2vecOllama(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-ollama} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecOllama(String vectorName) { + return Map.entry(vectorName, Text2VecOllamaVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-ollama} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecOllama(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecOllamaVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-openai} vectorizer. */ + public static Map.Entry text2vecOpenAi() { + return text2vecOpenAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-openai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecOpenAi( + Function> fn) { + return text2vecOpenAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-openai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecOpenAi(String vectorName) { + return Map.entry(vectorName, Text2VecOpenAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-openai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecOpenAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecOpenAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-transformers} vectorizer. */ + public static Map.Entry text2vecTransformers() { + return text2vecTransformers(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-transformers} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecTransformers( + Function> fn) { + return text2vecTransformers(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-transformers} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecTransformers(String vectorName) { + return Map.entry(vectorName, Text2VecTransformersVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-transformers} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecTransformers(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecTransformersVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-voyageai} vectorizer. */ + public static Map.Entry text2vecVoyageAi() { + return text2vecVoyageAi(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-voyageai} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecVoyageAi( + Function> fn) { + return text2vecVoyageAi(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-voyageai} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecVoyageAi(String vectorName) { + return Map.entry(vectorName, Text2VecVoyageAiVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-voyageai} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecVoyageAi(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecVoyageAiVectorizer.of(fn)); + } + + /** Create a vector index with an {@code text2vec-weaviate} vectorizer. */ + public static Map.Entry text2vecWeaviate() { + return text2vecWeaviate(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Create a vector index with an {@code text2vec-weaviate} vectorizer. + * + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecWeaviate( + Function> fn) { + return text2vecWeaviate(VectorIndex.DEFAULT_VECTOR_NAME, fn); + } + + /** + * Create a named vector index with an {@code text2vec-weaviate} vectorizer. + * + * @param vectorName Vector name. + */ + public static Map.Entry text2vecWeaviate(String vectorName) { + return Map.entry(vectorName, Text2VecWeaviateVectorizer.of()); + } + + /** + * Create a named vector index with an {@code text2vec-weaviate} vectorizer. + * + * @param vectorName Vector name. + * @param fn Lambda expression for optional parameters. + */ + public static Map.Entry text2vecWeaviate(String vectorName, + Function> fn) { + return Map.entry(vectorName, Text2VecWeaviateVectorizer.of(fn)); + } + + /** Is this an instance of {@link Img2VecNeuralVectorizer}? */ + default public boolean isImg2VecNeural() { + return _is(VectorConfig.Kind.IMG2VEC_NEURAL); + } + + /** Convert this instance to {@link Img2VecNeuralVectorizer}. */ + default public Img2VecNeuralVectorizer asImg2VecNeural() { + return _as(VectorConfig.Kind.IMG2VEC_NEURAL); + } + + /** Is this an instance of {@link Multi2MultiVecJinaAiVectorizer}? */ + default public boolean isMulti2MultiVecJinaAi() { + return _is(VectorConfig.Kind.MULTI2MULTIVEC_JINAAI); + } + + /** Convert this instance to {@link Multi2MultiVecJinaAiVectorizer}. */ + default public Multi2MultiVecJinaAiVectorizer asMulti2MultiVecJinaAi() { + return _as(VectorConfig.Kind.MULTI2MULTIVEC_JINAAI); + } + + /** Is this an instance of {@link Multi2VecAwsVectorizer}? */ + default public boolean isMulti2VecAws() { + return _is(VectorConfig.Kind.MULTI2VEC_AWS); + } + + /** Convert this instance to {@link Multi2VecAwsVectorizer}. */ + default public Multi2VecAwsVectorizer asMulti2VecAws() { + return _as(VectorConfig.Kind.MULTI2VEC_AWS); + } + + /** Is this an instance of {@link Multi2VecBindVectorizer}? */ + default public boolean isMulti2VecBind() { + return _is(VectorConfig.Kind.MULTI2VEC_BIND); + } + + /** Convert this instance to {@link Multi2VecBindVectorizer}. */ + default public Multi2VecBindVectorizer asMulti2VecBind() { + return _as(VectorConfig.Kind.MULTI2VEC_BIND); + } + + /** Is this an instance of {@link Multi2VecClipVectorizer}? */ + default public boolean isMulti2VecClip() { + return _is(VectorConfig.Kind.MULTI2VEC_CLIP); + } + + /** Convert this instance to {@link Multi2VecClipVectorizer}. */ + default public Multi2VecClipVectorizer asMulti2VecClip() { + return _as(VectorConfig.Kind.MULTI2VEC_CLIP); + } + + /** Is this an instance of {@link Multi2VecCohereVectorizer}? */ + default public boolean isMulti2VecCohere() { + return _is(VectorConfig.Kind.MULTI2VEC_COHERE); + } + + /** Convert this instance to {@link Multi2VecCohereVectorizer}. */ + default public Multi2VecCohereVectorizer asMulti2VecCohere() { + return _as(VectorConfig.Kind.MULTI2VEC_COHERE); + } + + /** Is this an instance of {@link Multi2VecGoogleVectorizer}? */ + default public boolean isMulti2VecGoogle() { + return _is(VectorConfig.Kind.MULTI2VEC_GOOGLE); + } + + /** Convert this instance to {@link Multi2VecGoogleVectorizer}. */ + default public Multi2VecGoogleVectorizer asMulti2VecGoogle() { + return _as(VectorConfig.Kind.MULTI2VEC_GOOGLE); + } + + /** Is this an instance of {@link Multi2VecJinaAiVectorizer}? */ + default public boolean isMulti2VecJinaAi() { + return _is(VectorConfig.Kind.MULTI2VEC_JINAAI); + } + + /** Convert this instance to {@link Multi2VecJinaAiVectorizer}. */ + default public Multi2VecJinaAiVectorizer asMulti2VecJinaAi() { + return _as(VectorConfig.Kind.MULTI2VEC_JINAAI); + } + + /** Is this an instance of {@link Multi2VecNvidiaVectorizer}? */ + default public boolean isMulti2VecNvidia() { + return _is(VectorConfig.Kind.MULTI2VEC_NVIDIA); + } + + /** Convert this instance to {@link Multi2VecNvidiaVectorizer}. */ + default public Multi2VecNvidiaVectorizer asMulti2VecNvidia() { + return _as(VectorConfig.Kind.MULTI2VEC_NVIDIA); + } + + /** Is this an instance of {@link Multi2VecVoyageAiVectorizer}? */ + default public boolean isMulti2VecVoyageAi() { + return _is(VectorConfig.Kind.MULTI2VEC_VOYAGEAI); + } + + /** Convert this instance to {@link Multi2VecVoyageAiVectorizer}. */ + default public Multi2VecVoyageAiVectorizer asMulti2VecVoyageAi() { + return _as(VectorConfig.Kind.MULTI2VEC_VOYAGEAI); + } + + /** Is this an instance of {@link Ref2VecCentroidVectorizer}? */ + default public boolean isRef2VecCentroid() { + return _is(VectorConfig.Kind.REF2VEC_CENTROID); + } + + /** Convert this instance to {@link Ref2VecCentroidVectorizer}. */ + default public Ref2VecCentroidVectorizer asRef2VecCentroid() { + return _as(VectorConfig.Kind.REF2VEC_CENTROID); + } + + /** Is this an instance of {@link Text2VecAwsVectorizer}? */ + default public boolean isText2VecAws() { + return _is(VectorConfig.Kind.TEXT2VEC_AWS); + } + + /** Convert this instance to {@link Text2VecAwsVectorizer}. */ + default public Text2VecAwsVectorizer asText2VecAws() { + return _as(VectorConfig.Kind.TEXT2VEC_AWS); + } + + /** Is this an instance of {@link Text2VecAzureOpenAiVectorizer}? */ + default public boolean isText2VecAzureOpenAi() { + return _is(VectorConfig.Kind.TEXT2VEC_AZURE_OPENAI); + } + + /** Convert this instance to {@link Text2VecAzureOpenAiVectorizer}. */ + default public Text2VecAzureOpenAiVectorizer asText2VecAzureOpenAi() { + return _as(VectorConfig.Kind.TEXT2VEC_AZURE_OPENAI); + } + + /** Is this an instance of {@link Text2VecCohereVectorizer}? */ + default public boolean isText2VecCohere() { + return _is(VectorConfig.Kind.TEXT2VEC_COHERE); + } + + /** Convert this instance to {@link Text2VecCohereVectorizer}. */ + default public Text2VecCohereVectorizer asText2VecCohere() { + return _as(VectorConfig.Kind.TEXT2VEC_COHERE); + } + + /** Is this an instance of {@link Text2VecDatabricksVectorizer}? */ + default public boolean isText2VecDatabricks() { + return _is(VectorConfig.Kind.TEXT2VEC_DATABRICKS); + } + + /** Convert this instance to {@link Text2VecDatabricksVectorizer}. */ + default public Text2VecDatabricksVectorizer asText2VecDatabricks() { + return _as(VectorConfig.Kind.TEXT2VEC_DATABRICKS); + } + + /** Is this an instance of {@link Text2VecGoogleVectorizer}? */ + default public boolean isText2VecGoogle() { + return _is(VectorConfig.Kind.TEXT2VEC_GOOGLE); + } + + /** Convert this instance to {@link Text2VecGoogleVectorizer}. */ + default public Text2VecGoogleVectorizer asText2VecGoogle() { + return _as(VectorConfig.Kind.TEXT2VEC_GOOGLE); + } + + /** Is this an instance of {@link Text2VecHuggingFaceVectorizer}? */ + default public boolean isText2VecHuggingFace() { + return _is(VectorConfig.Kind.TEXT2VEC_HUGGINGFACE); + } + + /** Convert this instance to {@link Text2VecHuggingFaceVectorizer}. */ + default public Text2VecHuggingFaceVectorizer asText2VecHuggingFace() { + return _as(VectorConfig.Kind.TEXT2VEC_HUGGINGFACE); + } + + /** Is this an instance of {@link Text2MultiVecJinaAiVectorizer}? */ + default public boolean isText2MultiVecJinaAi() { + return _is(VectorConfig.Kind.TEXT2MULTIVEC_JINAAI); + } + + /** Convert this instance to {@link Text2MultiVecJinaAiVectorizer}. */ + default public Text2MultiVecJinaAiVectorizer asText2MultiVecJinaAi() { + return _as(VectorConfig.Kind.TEXT2MULTIVEC_JINAAI); + } + + /** Is this an instance of {@link Text2VecJinaAiVectorizer}? */ + default public boolean isText2VecJinaAi() { + return _is(VectorConfig.Kind.TEXT2VEC_JINAAI); + } + + /** Convert this instance to {@link Text2VecJinaAiVectorizer}. */ + default public Text2VecJinaAiVectorizer asText2VecJinaAi() { + return _as(VectorConfig.Kind.TEXT2VEC_JINAAI); + } + + /** Is this an instance of {@link Text2VecMistralVectorizer}? */ + default public boolean isText2VecMistral() { + return _is(VectorConfig.Kind.TEXT2VEC_MISTRAL); + } + + /** Convert this instance to {@link Text2VecMistralVectorizer}. */ + default public Text2VecMistralVectorizer asText2VecMistral() { + return _as(VectorConfig.Kind.TEXT2VEC_MISTRAL); + } + + /** Is this an instance of {@link Text2VecModel2VecVectorizer}? */ + default public boolean isText2VecModel2Vec() { + return _is(VectorConfig.Kind.TEXT2VEC_MODEL2VEC); + } + + /** Convert this instance to {@link Text2VecModel2VecVectorizer}. */ + default public Text2VecModel2VecVectorizer asText2VecModel2Vec() { + return _as(VectorConfig.Kind.TEXT2VEC_MODEL2VEC); + } + + /** Is this an instance of {@link Text2VecMorphVectorizer}? */ + default public boolean isText2VecMorph() { + return _is(VectorConfig.Kind.TEXT2VEC_MORPH); + } + + /** Convert this instance to {@link Text2VecMorphVectorizer}. */ + default public Text2VecMorphVectorizer asText2VecMorph() { + return _as(VectorConfig.Kind.TEXT2VEC_MORPH); + } + + /** Is this an instance of {@link Text2VecNvidiaVectorizer}? */ + default public boolean isText2VecNvidia() { + return _is(VectorConfig.Kind.TEXT2VEC_NVIDIA); + } + + /** Convert this instance to {@link Text2VecNvidiaVectorizer}. */ + default public Text2VecNvidiaVectorizer asText2VecNvidia() { + return _as(VectorConfig.Kind.TEXT2VEC_NVIDIA); + } + + /** Is this an instance of {@link Text2VecOllamaVectorizer}? */ + default public boolean isText2VecOllama() { + return _is(VectorConfig.Kind.TEXT2VEC_OLLAMA); + } + + /** Convert this instance to {@link Text2VecOllamaVectorizer}. */ + default public Text2VecOllamaVectorizer asText2VecOllama() { + return _as(VectorConfig.Kind.TEXT2VEC_OLLAMA); + } + + /** Is this an instance of {@link Text2VecOpenAiVectorizer}? */ + default public boolean isText2VecOpenAi() { + return _is(VectorConfig.Kind.TEXT2VEC_OPENAI); + } + + /** Convert this instance to {@link Text2VecOpenAiVectorizer}. */ + default public Text2VecOpenAiVectorizer asText2VecOpenAi() { + return _as(VectorConfig.Kind.TEXT2VEC_OPENAI); + } + + /** Is this an instance of {@link Text2VecTransformersVectorizer}? */ + default public boolean isText2VecTransformers() { + return _is(VectorConfig.Kind.TEXT2VEC_TRANSFORMERS); + } + + /** Convert this instance to {@link Text2VecTransformersVectorizer}. */ + default public Text2VecTransformersVectorizer asText2VecTransformers() { + return _as(VectorConfig.Kind.TEXT2VEC_TRANSFORMERS); + } + + /** Is this an instance of {@link Text2VecVoyageAiVectorizer}? */ + default public boolean isText2VecVoyageAi() { + return _is(VectorConfig.Kind.TEXT2VEC_VOYAGEAI); + } + + /** Convert this instance to {@link Text2VecVoyageAiVectorizer}. */ + default public Text2VecVoyageAiVectorizer asText2VecVoyageAi() { + return _as(VectorConfig.Kind.TEXT2VEC_VOYAGEAI); + } + + /** Is this an instance of {@link Text2VecWeaviateVectorizer}? */ + default public boolean isText2VecWeaviate() { + return _is(VectorConfig.Kind.TEXT2VEC_WEAVIATE); + } + + /** Convert this instance to {@link Text2VecWeaviateVectorizer}. */ + default public Text2VecWeaviateVectorizer asText2VecWeaviate() { + return _as(VectorConfig.Kind.TEXT2VEC_WEAVIATE); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> delegateAdapters = new EnumMap<>( + VectorConfig.Kind.class); + + private final void addAdapter(Gson gson, VectorConfig.Kind kind, Class cls) { + delegateAdapters.put(kind, + (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, VectorConfig.Kind.NONE, SelfProvidedVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_AWS, Text2VecAwsVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_COHERE, Text2VecCohereVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_DATABRICKS, Text2VecDatabricksVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_GOOGLE, Text2VecGoogleVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_HUGGINGFACE, Text2VecHuggingFaceVectorizer.class); + addAdapter(gson, VectorConfig.Kind.REF2VEC_CENTROID, Ref2VecCentroidVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_JINAAI, Text2VecJinaAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_MISTRAL, Text2VecMistralVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_MORPH, Text2VecMorphVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_MODEL2VEC, Text2VecModel2VecVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_NVIDIA, Text2VecNvidiaVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_OPENAI, Text2VecOpenAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_AZURE_OPENAI, Text2VecAzureOpenAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_OLLAMA, Text2VecOllamaVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_TRANSFORMERS, Text2VecTransformersVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_VOYAGEAI, Text2VecVoyageAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2VEC_WEAVIATE, Text2VecWeaviateVectorizer.class); + addAdapter(gson, VectorConfig.Kind.IMG2VEC_NEURAL, Img2VecNeuralVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_AWS, Multi2VecAwsVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_BIND, Multi2VecBindVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_CLIP, Multi2VecClipVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_GOOGLE, Multi2VecGoogleVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_COHERE, Multi2VecCohereVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_JINAAI, Multi2VecJinaAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_NVIDIA, Multi2VecNvidiaVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2VEC_VOYAGEAI, Multi2VecVoyageAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.TEXT2MULTIVEC_JINAAI, Text2MultiVecJinaAiVectorizer.class); + addAdapter(gson, VectorConfig.Kind.MULTI2MULTIVEC_JINAAI, Multi2MultiVecJinaAiVectorizer.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + final var rawType = type.getRawType(); + if (!VectorConfig.class.isAssignableFrom(rawType)) { + return null; + } + + if (delegateAdapters.isEmpty()) { + init(gson); + } + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, VectorConfig value) throws IOException { + TypeAdapter adapter = (TypeAdapter) delegateAdapters.get(value._kind()); + + // Serialize vectorizer config as { "vectorizer-kind": { ... } } + // and remove "vectorIndex" and quantization objects which every vectorizer has. + var vectorizer = new JsonObject(); + var config = adapter.toJsonTree((T) value._self()); + + // This will create { "vectorIndexType": "", "vectorIndexConfig": { ... } } + // to which we just need to add "vectorizer": { ... } key + // and "bq"/"pg"/"sq"/"rq": { ... } (quantizer) key. + var vectorIndex = config.getAsJsonObject().remove("vectorIndex"); + + vectorizer.add(value._kind().jsonValue(), config); + vectorIndex.getAsJsonObject().add("vectorizer", vectorizer); + + if (value.quantization() != null && !config.getAsJsonObject().get("quantization").isJsonNull()) { + vectorIndex.getAsJsonObject() + .get("vectorIndexConfig").getAsJsonObject() + .add(value.quantization()._kind().jsonValue(), config.getAsJsonObject().remove("quantization")); + } + + Streams.write(vectorIndex, out); + } + + @Override + public VectorConfig read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + var vectorIndexConfig = jsonObject.get("vectorIndexConfig").getAsJsonObject(); + + String quantizationKind = null; + for (var kind : new String[] { + Quantization.Kind.BQ.jsonValue(), + Quantization.Kind.PQ.jsonValue(), + Quantization.Kind.SQ.jsonValue(), + Quantization.Kind.RQ.jsonValue() }) { + if (vectorIndexConfig.has(kind) + && vectorIndexConfig.get(kind).getAsJsonObject().get("enabled").getAsBoolean()) { + quantizationKind = kind; + } + } + if (quantizationKind == null && vectorIndexConfig.has(Quantization.Kind.UNCOMPRESSED.jsonValue()) + && vectorIndexConfig.get(Quantization.Kind.UNCOMPRESSED.jsonValue()).getAsBoolean()) { + quantizationKind = Quantization.Kind.UNCOMPRESSED.jsonValue(); + } + + // VectorIndex.CustomTypeAdapterFactory expects keys + // ["vectorIndexType", "vectorIndexConfig"]. + var vectorIndex = new JsonObject(); + vectorIndex.add("vectorIndexType", jsonObject.get("vectorIndexType")); + vectorIndex.add("vectorIndexConfig", vectorIndexConfig); + + var vectorizerObject = jsonObject.get("vectorizer").getAsJsonObject(); + var vectorizerName = vectorizerObject.keySet().iterator().next(); + var concreteVectorizer = vectorizerObject.get(vectorizerName).getAsJsonObject(); + + // Each individual vectorizer has a `VectorIndex vectorIndex` field. + concreteVectorizer.add("vectorIndex", vectorIndex); + + VectorConfig.Kind kind; + if (vectorizerName.equals(VectorConfig.Kind.TEXT2VEC_OPENAI.jsonValue())) { + kind = concreteVectorizer.has("deployementId") + ? VectorConfig.Kind.TEXT2VEC_AZURE_OPENAI + : VectorConfig.Kind.TEXT2VEC_OPENAI; + } else { + try { + kind = VectorConfig.Kind.valueOfJson(vectorizerName); + } catch (IllegalArgumentException e) { + return null; + } + } + + var adapter = delegateAdapters.get(kind); + + // Each individual vectorizer has a `Quantization quantization` field. + // We need to specify the kind in order for + // Quantization.CustomTypeAdapterFactory to be able to find the right adapter. + if (quantizationKind != null && vectorIndexConfig.has(quantizationKind)) { + JsonObject quantization = new JsonObject(); + quantization.add(quantizationKind, vectorIndexConfig.get(quantizationKind)); + concreteVectorizer.add("quantization", quantization); + } else { + concreteVectorizer.add("quantization", null); + } + return adapter.fromJsonTree(concreteVectorizer); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/VectorIndex.java b/src/main/java/io/weaviate/client6/v1/api/collections/VectorIndex.java new file mode 100644 index 000000000..df3064d6c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/VectorIndex.java @@ -0,0 +1,146 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.Map; + +import com.google.gson.Gson; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.vectorindex.Dynamic; +import io.weaviate.client6.v1.api.collections.vectorindex.Flat; +import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw; +import io.weaviate.client6.v1.internal.TaggedUnion; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface VectorIndex extends TaggedUnion { + static final String DEFAULT_VECTOR_NAME = "default"; + static final VectorIndex DEFAULT_VECTOR_INDEX = Hnsw.of(); + + enum Kind implements JsonEnum { + HNSW("hnsw"), + FLAT("flat"), + DYNAMIC("dynamic"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return this.jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + /** Is this vector index of type HNSW? */ + default boolean isHnsw() { + return _is(VectorIndex.Kind.HNSW); + } + + /** Get as {@link Hnsw} instance. */ + default Hnsw asHnsw() { + return _as(VectorIndex.Kind.HNSW); + } + + /** Is this vector index of type FLAT? */ + default boolean isFlat() { + return _is(VectorIndex.Kind.FLAT); + } + + /** Get as {@link Flat} instance. */ + default Flat asFlat() { + return _as(VectorIndex.Kind.FLAT); + } + + /** Is this vector index of type DYNAMIC? */ + default boolean isDynamic() { + return _is(VectorIndex.Kind.DYNAMIC); + } + + /** Get as {@link Dynamic} instance. */ + default Dynamic asDynamic() { + return _as(VectorIndex.Kind.DYNAMIC); + } + + static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> readAdapters = new EnumMap<>( + VectorIndex.Kind.class); + + private final void addAdapter(Gson gson, VectorIndex.Kind kind, Class cls) { + readAdapters.put(kind, (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, VectorIndex.Kind.HNSW, Hnsw.class); + addAdapter(gson, VectorIndex.Kind.FLAT, Flat.class); + addAdapter(gson, VectorIndex.Kind.DYNAMIC, Dynamic.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + var rawType = type.getRawType(); + if (!VectorIndex.class.isAssignableFrom(rawType)) { + return null; + } + + if (readAdapters.isEmpty()) { + init(gson); + } + + final var writeAdapter = gson.getDelegateAdapter(this, TypeToken.get(rawType)); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, VectorIndex value) throws IOException { + out.beginObject(); + out.name("vectorIndexType"); + out.value(value._kind().jsonValue()); + + out.name("vectorIndexConfig"); + var config = writeAdapter.toJsonTree((T) value._self()); + config.getAsJsonObject().remove("name"); + Streams.write(config, out); + + out.endObject(); + } + + @Override + public VectorIndex read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + + VectorIndex.Kind kind; + var kindString = jsonObject.get("vectorIndexType").getAsString(); + try { + kind = VectorIndex.Kind.valueOfJson(kindString); + } catch (IllegalArgumentException e) { + return null; + } + + var adapter = readAdapters.get(kind); + if (adapter == null) { + return null; + } + + var config = jsonObject.get("vectorIndexConfig").getAsJsonObject(); + return adapter.fromJsonTree(config); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Vectors.java b/src/main/java/io/weaviate/client6/v1/api/collections/Vectors.java new file mode 100644 index 000000000..1a0b3203b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/Vectors.java @@ -0,0 +1,228 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +/** + * Vectors is an abstraction over named vectors, which can store + * both 1-dimensional and 2-dimensional vectors. + */ +public class Vectors { + /** Elements of this map must only be {@code float[]} or {@code float[][]}. */ + private final Map vectorsMap; + + /** Create a 1-dimensional vector. */ + public static Vectors of(float[] vector) { + return of(VectorIndex.DEFAULT_VECTOR_NAME, vector); + } + + /** Create a named 1-dimensional vector. */ + public static Vectors of(String name, float[] vector) { + return new Vectors(name, vector); + } + + /** Create a 2-dimensional vector. */ + public static Vectors of(float[][] vector) { + return of(VectorIndex.DEFAULT_VECTOR_NAME, vector); + } + + /** Create a named 2-dimensional vector. */ + public static Vectors of(String name, float[][] vector) { + return new Vectors(name, vector); + } + + /** + * Create a single named vector. + * + *

+ * Callers must ensure that vectors are either + * {@code float[]} or {@code float[][]}. + * + * @param name Vector name. + * @param vector {@code float[]} or {@code float[][]} vector. + */ + private Vectors(String name, Object vector) { + this.vectorsMap = Collections.singletonMap(name, vector); + } + + /** + * Create a Vectors from a map. + * + *

+ * Callers must ensure that vectors are either + * {@code float[]} or {@code float[][]}. + * + * @param name Vector name. + * @param vector Map of named vectors. + */ + private Vectors(Map namedVectors) { + this.vectorsMap = namedVectors; + } + + /** Merge all vectors in a single vector map. */ + public Vectors(Vectors... vectors) { + var namedVectors = new HashMap(); + for (var vec : vectors) { + namedVectors.putAll(vec.asMap()); + } + this.vectorsMap = namedVectors; + } + + /** + * Add more vector objects. + * + * @param vectors Vector objects. + * @return A new {@code Vectors} object containing all vectors. + */ + public Vectors withVectors(Vectors... vectors) { + var combined = new HashMap<>(vectorsMap); + for (var v : vectors) { + combined.putAll(v.vectorsMap); + } + return new Vectors(combined); + } + + /** + * Check if a vector exists in the query result. + * + * @param name Vector name. + */ + public boolean contains(String name) { + return vectorsMap.containsKey(name); + } + + /** Returns the number of vectors contained. */ + public int size() { + return vectorsMap.size(); + } + + /** + * Get 1-dimensional vector by name. + * + * @return Vector as {@code float[]} or {@code null}. + * @throws ClassCastException The underlying vector is not a {@code float[]}. + */ + public float[] getSingle(String name) { + return (float[]) vectorsMap.get(name); + } + + /** + * Get default 1-dimensional vector. + * + * @return Vector as {@code float[]} or {@code null}. + * @throws ClassCastException if the underlying object is not a {@code float[]}. + */ + public float[] getDefaultSingle() { + return getSingle(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Get 2-dimensional vector by name. + * + * @return Vector as {@code float[][]} or {@code null}. + * @throws ClassCastException if the underlying object is not a + * {@code float[][]}. + */ + public float[][] getMulti(String name) { + return (float[][]) vectorsMap.get(name); + } + + /** + * Get default 2-dimensional vector. + * + * @return Vector as {@code float[][]} or {@code null}. + * @throws ClassCastException if the underlying object is not a + * {@code float[][]}. + */ + public float[][] getDefaultMulti() { + return getMulti(VectorIndex.DEFAULT_VECTOR_NAME); + } + + /** + * Get all vectors. + * Each element is either a {@code float[]} or a {@code float[][]}. + * + * + * @return Map of name-vector pairs. The returned map is immutable. + */ + public Map asMap() { + return Map.copyOf(vectorsMap); + } + + @Override + public String toString() { + var vectorStrings = vectorsMap.entrySet().stream() + .map(v -> { + var name = v.getKey(); + var value = v.getValue(); + var array = (value instanceof float[]) + ? Arrays.toString((float[]) value) + : Arrays.deepToString((float[][]) value); + return "%s=%s".formatted(name, array); + }) + .toList(); + return "Vectors(%s)".formatted(String.join(", ", vectorStrings)); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + if (type.getRawType() != Vectors.class) { + return null; + } + final var mapAdapter = gson.getDelegateAdapter(this, new TypeToken>() { + }); + final var float_1d = gson.getDelegateAdapter(this, TypeToken.get(float[].class)); + final var float_2d = gson.getDelegateAdapter(this, TypeToken.get(float[][].class)); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Vectors value) throws IOException { + mapAdapter.write(out, value.vectorsMap); + } + + @Override + public Vectors read(JsonReader in) throws IOException { + var vectorsMap = JsonParser.parseReader(in).getAsJsonObject().asMap(); + var namedVectors = new HashMap(); + + for (var entry : vectorsMap.entrySet()) { + String vectorName = entry.getKey(); + JsonElement el = entry.getValue(); + if (el.isJsonArray()) { + JsonArray array = el.getAsJsonArray(); + Object vector; + if (array.size() > 0 && array.get(0).isJsonArray()) { + vector = float_2d.fromJsonTree(array); + } else { + vector = float_1d.fromJsonTree(array); + } + + assert (vector instanceof float[]) || (vector instanceof float[][]) + : "invalid vector type " + vector.getClass(); + + namedVectors.put(vectorName, vector); + } + } + return new Vectors(namedVectors); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java new file mode 100644 index 000000000..c0fca9bbc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java @@ -0,0 +1,286 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateCollectionsClient { + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + public WeaviateCollectionsClient(RestTransport restTransport, GrpcTransport grpcTransport) { + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param cls Class that represents an object in the collection. + * @return a handle for a collection with {@code Class} + * properties. + */ + public CollectionHandle use(Class cls) { + return use(CollectionDescriptor.ofClass(cls), CollectionHandleDefaults.none()); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param cls Class that represents an object in the collection. + * @param fn Lamda expression for optional parameters. + * @return a handle for a collection with {@code Class} + * properties. + */ + public CollectionHandle use( + Class cls, + Function> fn) { + return use(CollectionDescriptor.ofClass(cls), fn); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param collectionName Name of the collection. + * @return a handle for a collection with {@code Map} + * properties. + */ + public CollectionHandle> use(String collectionName) { + return use(collectionName, CollectionHandleDefaults.none()); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param collectionName Name of the collection. + * @param fn Lamda expression for optional parameters. + * @return a handle for a collection with {@code Map} + * properties. + */ + public CollectionHandle> use( + String collectionName, + Function> fn) { + return use(CollectionDescriptor.ofMap(collectionName), fn); + } + + private CollectionHandle use(CollectionDescriptor collection, + Function> fn) { + return new CollectionHandle<>(restTransport, grpcTransport, collection, CollectionHandleDefaults.of(fn)); + } + + /** + * Create a new Weaviate collection with default configuration. + * + *

{@code
+   * // Define a record class that represents an object in collection.
+   * record Song(
+   *  String title;
+   *  int yearReleased;
+   *  String[] genres;
+   * ) {}
+   *
+   * client.collections.create(Song.class);
+   * }
+ * + * @param cls Class that represents an object in the collection. + * @return Handle for the created collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * @see io.weaviate.client6.v1.api.collections.annotations.Collection + * @see io.weaviate.client6.v1.api.collections.annotations.Property + */ + public CollectionHandle create(Class cls) throws IOException { + var collection = CollectionDescriptor.ofClass(cls); + create(CollectionConfig.of(collection.collectionName(), collection.configFn())); + return use(cls); + } + + /** + * Create and configure a new Weaviate collection. See + * {@link CollectionConfig.Builder} for available options. + * + * @param cls Class that represents an object in the collection. + * @param fn Lamda expression for optional parameters. + * @return Handle for the created collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + * @see io.weaviate.client6.v1.api.collections.annotations.Collection + * @see io.weaviate.client6.v1.api.collections.annotations.Property + * @see WeaviateCollectionsClient#create(Class) + */ + public CollectionHandle create( + Class cls, + Function> fn) throws IOException { + var collection = CollectionDescriptor.ofClass(cls); + var configFn = ObjectBuilder.partial(fn, collection.configFn()); + create(CollectionConfig.of(collection.collectionName(), configFn)); + return use(cls); + } + + /** + * Create a new Weaviate collection with default configuration. + * + * @param collectionName Collection name. + * @return Handle for the created collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public CollectionHandle> create(String collectionName) throws IOException { + return create(CollectionConfig.of(collectionName)); + } + + /** + * Create and configure a new Weaviate collection. See + * {@link CollectionConfig.Builder} for available options. + * + * @param collectionName Collection name. + * @param fn Lamda expression for optional parameters. + * @return Handle for the created collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public CollectionHandle> create(String collectionName, + Function> fn) throws IOException { + return create(CollectionConfig.of(collectionName, fn)); + } + + /** + * Create a new Weaviate collection with {@link CollectionConfig}. + * + * @return Handle for the created collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public CollectionHandle> create(CollectionConfig collection) throws IOException { + this.restTransport.performRequest(new CreateCollectionRequest(collection), + CreateCollectionRequest._ENDPOINT); + return use(collection.collectionName()); + } + + /** + * Fetch Weaviate collection configuration. + * + * @param collectionName Collection name. + * @return the collection configuration if one with this name exists. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional getConfig(String collectionName) throws IOException { + return this.restTransport.performRequest(new GetConfigRequest(collectionName), GetConfigRequest._ENDPOINT); + } + + /** + * Fetch configurations for all collections in Weaviate. + * + * @return a list of collection configurations. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list() throws IOException { + return this.restTransport.performRequest(new ListCollectionRequest(), ListCollectionRequest._ENDPOINT); + } + + /** + * Delete a Weaviate collection. + * + * @param collectionName Collection name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(String collectionName) throws IOException { + this.restTransport.performRequest(new DeleteCollectionRequest(collectionName), DeleteCollectionRequest._ENDPOINT); + } + + /** + * Delete a Weaviate collection. + * + * @param cls Class that represents an object in the collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(Class cls) throws IOException { + delete(CollectionDescriptor.ofClass(cls).collectionName()); + } + + /** + * Delete all collections in Weaviate. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void deleteAll() throws IOException { + for (var collection : list()) { + delete(collection.collectionName()); + } + } + + /** + * Check if a collection with this name exists. + * + * @param collectionName Collection name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean exists(String collectionName) throws IOException { + return getConfig(collectionName).isPresent(); + } + + /** + * Check if a collection with this name exists. + * + * @param cls Class that represents an object in the collection. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean exists(Class cls) throws IOException { + return exists(CollectionDescriptor.ofClass(cls).collectionName()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java new file mode 100644 index 000000000..ba80f715e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java @@ -0,0 +1,215 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateCollectionsClientAsync { + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + public WeaviateCollectionsClientAsync(RestTransport restTransport, GrpcTransport grpcTransport) { + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param cls Class that represents an object in the collection. + * @return a handle for a collection with {@code PropertiesT} properties. + */ + public CollectionHandleAsync use(Class cls) { + return use(CollectionDescriptor.ofClass(cls), CollectionHandleDefaults.none()); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param cls Class that represents an object in the collection. + * @param fn Lamda expression for optional parameters. + * @return a handle for a collection with {@code PropertiesT} properties. + */ + public CollectionHandleAsync use( + Class cls, + Function> fn) { + return use(CollectionDescriptor.ofClass(cls), fn); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param collectionName Name of the collection. + * @return a handle for a collection with {@code Map} + * properties. + */ + public CollectionHandleAsync> use(String collectionName) { + return use(collectionName, CollectionHandleDefaults.none()); + } + + /** + * Obtain a handle to send requests to a particular collection. + * The returned object is thread-safe. + * + * @param collectionName Name of the collection. + * @param fn Lamda expression for optional parameters. + * @return a handle for a collection with {@code Map} + * properties. + */ + public CollectionHandleAsync> use( + String collectionName, + Function> fn) { + return use(CollectionDescriptor.ofMap(collectionName), fn); + } + + private CollectionHandleAsync use(CollectionDescriptor collection, + Function> fn) { + return new CollectionHandleAsync<>(restTransport, grpcTransport, collection, CollectionHandleDefaults.of(fn)); + } + + /** + * Create a new Weaviate collection with default configuration. + * + *
{@code
+   * // Define a record class that represents an object in collection.
+   * record Song(
+   *  String title;
+   *  int yearReleased;
+   *  String[] genres;
+   * ) {}
+   *
+   * client.collections.create(Song.class);
+   * }
+ * + * @param cls Class that represents an object in the collection. + * @see io.weaviate.client6.v1.api.collections.annotations.Collection + * @see io.weaviate.client6.v1.api.collections.annotations.Property + */ + public CompletableFuture> create( + Class cls) { + var collection = CollectionDescriptor.ofClass(cls); + return create(CollectionConfig.of(collection.collectionName(), collection.configFn())) + .thenApply(__ -> use(cls)); + } + + /** + * Create and configure a new Weaviate collection. See + * {@link CollectionConfig.Builder} for available options. + * + * @param cls Class that represents an object in the collection. + * @param fn Lamda expression for optional parameters. + * @see io.weaviate.client6.v1.api.collections.annotations.Collection + * @see io.weaviate.client6.v1.api.collections.annotations.Property + * @see WeaviateCollectionsClientAsync#create(Class) + */ + public CompletableFuture> create( + Class cls, + Function> fn) { + var collection = CollectionDescriptor.ofClass(cls); + var configFn = ObjectBuilder.partial(fn, collection.configFn()); + return create(CollectionConfig.of(collection.collectionName(), configFn)) + .thenApply(__ -> use(cls)); + } + + /** + * Create a new Weaviate collection with default configuration. + * + * @param collectionName Collection name. + */ + public CompletableFuture>> create(String collectionName) { + return create(CollectionConfig.of(collectionName)); + } + + /** + * Create and configure a new Weaviate collection. See + * {@link CollectionConfig.Builder} for available options. + * + * @param collectionName Collection name. + * @param fn Lamda expression for optional parameters. + */ + public CompletableFuture>> create(String collectionName, + Function> fn) { + return create(CollectionConfig.of(collectionName, fn)); + } + + /** + * Create a new Weaviate collection with {@link CollectionConfig}. + */ + public CompletableFuture>> create(CollectionConfig collection) { + return this.restTransport.performRequestAsync(new CreateCollectionRequest(collection), + CreateCollectionRequest._ENDPOINT).thenApply(__ -> use(collection.collectionName())); + } + + /** + * Fetch Weaviate collection configuration. + * + * @param collectionName Collection name. + */ + public CompletableFuture> getConfig(String collectionName) { + return this.restTransport.performRequestAsync(new GetConfigRequest(collectionName), GetConfigRequest._ENDPOINT); + } + + public CompletableFuture> list() { + return this.restTransport.performRequestAsync(new ListCollectionRequest(), ListCollectionRequest._ENDPOINT); + } + + /** + * Delete a Weaviate collection. + * + * @param collectionName Collection name. + */ + public CompletableFuture delete(String collectionName) { + return this.restTransport.performRequestAsync(new DeleteCollectionRequest(collectionName), + DeleteCollectionRequest._ENDPOINT); + } + + /** + * Delete a Weaviate collection. + * + * @param cls Class that represents an object in the collection. + */ + public CompletableFuture delete(Class cls) { + return delete(CollectionDescriptor.ofClass(cls).collectionName()); + } + + /** + * Delete all collections in Weaviate. + */ + public CompletableFuture deleteAll() throws IOException { + return list().thenCompose(collections -> { + var futures = collections.stream() + .map(collection -> delete(collection.collectionName())) + .toArray(CompletableFuture[]::new); + return CompletableFuture.allOf(futures); + }); + } + + /** + * Check if a collection with this name exists. + * + * @param collectionName Collection name. + */ + public CompletableFuture exists(String collectionName) { + return getConfig(collectionName).thenApply(Optional::isPresent); + } + + /** + * Check if a collection with this name exists. + * + * @param cls Class that represents an object in the collection. + */ + public CompletableFuture exists(Class cls) { + return exists(CollectionDescriptor.ofClass(cls).collectionName()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java new file mode 100644 index 000000000..7faf0e20b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java @@ -0,0 +1,209 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.lang.reflect.ParameterizedType; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.annotations.SerializedName; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.query.QueryMetadata; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record WeaviateObject( + @SerializedName("id") String uuid, + @SerializedName("class") String collection, + @SerializedName("tenant") String tenant, + @SerializedName("properties") PropertiesT properties, + @SerializedName("vectors") Vectors vectors, + @SerializedName("creationTimeUnix") Long createdAt, + @SerializedName("lastUpdateTimeUnix") Long lastUpdatedAt, + + QueryMetadata queryMetadata, + Map> references) implements Reference { + + @SuppressWarnings("unchecked") + @Override + public WeaviateObject> asWeaviateObject() { + return (WeaviateObject>) this; + } + + public static WeaviateObject of( + Function, ObjectBuilder>> fn) { + return fn.apply(new Builder<>()).build(); + } + + public WeaviateObject(Builder builder) { + this( + builder.uuid, + null, // collection name is derived from CollectionHandle + builder.tenant, // tenant MAY be derived from CollectionHandle + builder.properties, + builder.vectors, + null, // createdAt is read-only + null, // lastUpdatedAt is read-only + null, // queryMetadata is read-only + builder.references); + } + + public static class Builder implements ObjectBuilder> { + /** + * The server should be providing default UUIDs, but it does not do that + * during batch inserts and we have to provide our own. + * Rather than make this behaviour special to {@code insertMany}, we are going + * to provide a fallback UUID "globally". + */ + private String uuid = UUID.randomUUID().toString(); + private String tenant; + private PropertiesT properties; + private Vectors vectors; + private Map> references = new HashMap<>(); + + public Builder uuid(String uuid) { + this.uuid = uuid; + return this; + } + + public Builder tenant(String tenant) { + this.tenant = tenant; + return this; + } + + public Builder properties(PropertiesT properties) { + this.properties = properties; + return this; + } + + /** + * Add a reference. Calls to {@link #reference} can be chained + * to add multiple references. + */ + public Builder reference(String property, Reference... references) { + for (var ref : references) { + addReference(property, ref); + } + return this; + } + + public Builder references(Map> references) { + this.references = references; + return this; + } + + private void addReference(String property, Reference reference) { + if (!references.containsKey(property)) { + references.put(property, new ArrayList<>()); + } + references.get(property).add(reference); + } + + public Builder vectors(Vectors... vectors) { + if (this.vectors == null) { + this.vectors = vectors.length == 1 ? vectors[0] : new Vectors(vectors); + } else { + this.vectors = this.vectors.withVectors(vectors); + } + return this; + } + + @Override + public WeaviateObject build() { + return new WeaviateObject<>(this); + } + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken typeToken) { + var type = typeToken.getType(); + var rawType = typeToken.getRawType(); + if (rawType != WeaviateObject.class || + !(type instanceof ParameterizedType parameterized) + || parameterized.getActualTypeArguments().length != 1) { + return null; + } + + var typeParams = parameterized.getActualTypeArguments(); + final var propertiesType = typeParams[0]; + + final var delegate = (TypeAdapter>) gson + .getDelegateAdapter(this, typeToken); + final var propertiesAdapter = (TypeAdapter) gson.getAdapter(TypeToken.get(propertiesType)); + final var referencesAdapter = gson.getAdapter(ObjectReference.class); + + return (TypeAdapter) new TypeAdapter>() { + + @Override + public void write(JsonWriter out, WeaviateObject value) throws IOException { + var json = delegate.toJsonTree(value).getAsJsonObject(); + var properties = value.properties() != null + ? propertiesAdapter.toJsonTree(value.properties()).getAsJsonObject() + : new JsonObject(); + + if (value.references() != null && !value.references().isEmpty()) { + for (var refEntry : value.references().entrySet()) { + var beacons = new JsonArray(); + for (var reference : refEntry.getValue()) { + var beacon = referencesAdapter.toJsonTree((ObjectReference) reference); + beacons.add(beacon); + } + properties.add(refEntry.getKey(), beacons); + } + } + + json.add("properties", properties); + json.remove("references"); + Streams.write(json, out); + } + + @Override + public WeaviateObject read(JsonReader in) throws IOException { + var json = JsonParser.parseReader(in).getAsJsonObject(); + + var jsonProperties = json.get("properties").getAsJsonObject(); + var objectProperties = new JsonObject(); + var objectReferences = new JsonObject(); + + for (var property : jsonProperties.entrySet()) { + var value = property.getValue(); + + if (value.isJsonArray()) { + var array = value.getAsJsonArray(); + var first = array.get(0); + var isReference = first.isJsonObject() && first.getAsJsonObject().has("beacon"); + + if (isReference) { + objectReferences.add(property.getKey(), value); + continue; + } + } + + objectProperties.add(property.getKey(), value); + } + + json.add("references", objectReferences); + json.add("properties", objectProperties); + return delegate.fromJsonTree(json); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java new file mode 100644 index 000000000..8d36dbcbb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java @@ -0,0 +1,2009 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.Hybrid; +import io.weaviate.client6.v1.api.collections.query.NearAudio; +import io.weaviate.client6.v1.api.collections.query.NearDepth; +import io.weaviate.client6.v1.api.collections.query.NearImage; +import io.weaviate.client6.v1.api.collections.query.NearImu; +import io.weaviate.client6.v1.api.collections.query.NearObject; +import io.weaviate.client6.v1.api.collections.query.NearText; +import io.weaviate.client6.v1.api.collections.query.NearThermal; +import io.weaviate.client6.v1.api.collections.query.NearVector; +import io.weaviate.client6.v1.api.collections.query.NearVectorTarget; +import io.weaviate.client6.v1.api.collections.query.NearVideo; +import io.weaviate.client6.v1.api.collections.query.Target; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +abstract class AbstractAggregateClient { + protected final CollectionDescriptor collection; + protected final GrpcTransport transport; + protected final CollectionHandleDefaults defaults; + + AbstractAggregateClient( + CollectionDescriptor collection, + GrpcTransport transport, + CollectionHandleDefaults defaults) { + this.transport = transport; + this.collection = collection; + this.defaults = defaults; + } + + AbstractAggregateClient( + AbstractAggregateClient c, + CollectionHandleDefaults defaults) { + this(c.collection, c.transport, defaults); + } + + protected abstract ResponseT performRequest(Aggregation aggregation); + + protected abstract GroupedResponseT performRequest(Aggregation aggregation, GroupBy groupBy); + + // OverAll ------------------------------------------------------------------ + + /** + * Aggregate metrics over all objects in this collection. + * + * @param fn Lambda expression for optional parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT overAll(Function> fn) { + return performRequest(Aggregation.of(fn)); + } + + /** + * Aggregate metrics over all objects in this collection. + * + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT overAll(GroupBy groupBy) { + return performRequest(Aggregation.of(), groupBy); + } + + /** + * Aggregate metrics over all objects in this collection. + * + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT overAll(Function> fn, GroupBy groupBy) { + return performRequest(Aggregation.of(fn), groupBy); + } + + // Hybrid ------------------------------------------------------------------- + + /** + * Aggregate results of a hybrid search query. + * + * @param query Query string. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT hybrid(String query, Function> fn) { + return hybrid(Hybrid.of(query), fn); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT hybrid(Target searchTarget, Function> fn) { + return hybrid(Hybrid.of(searchTarget), fn); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param query Query string. + * @param hybrid Lambda expression for optional hybrid search parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT hybrid(String query, Function> hybrid, + Function> fn) { + return hybrid(Hybrid.of(query, hybrid), fn); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param searchTarget Query target. + * @param hybrid Lambda expression for optional hybrid search parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT hybrid(Target searchTarget, Function> hybrid, + Function> fn) { + return hybrid(Hybrid.of(searchTarget, hybrid), fn); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param filter Hybrid query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT hybrid(Hybrid filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param query Query string. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT hybrid(String query, Function> fn, + GroupBy groupBy) { + return hybrid(Hybrid.of(query), fn, groupBy); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT hybrid(Target searchTarget, Function> fn, + GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param query Query string. + * @param hybrid Lambda expression for optional hybrid search parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT hybrid(String query, Function> hybrid, + Function> fn, GroupBy groupBy) { + return hybrid(Hybrid.of(query, hybrid), fn, groupBy); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param searchTarget Query target. + * @param hybrid Lambda expression for optional hybrid search parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT hybrid(Target searchTarget, Function> hybrid, + Function> fn, GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget, hybrid), fn, groupBy); + } + + /** + * Aggregate results of a hybrid search query. + * + * @param filter Hybrid query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT hybrid(Hybrid filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearVector --------------------------------------------------------------- + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(float[] vector, + Function> fn) { + return nearVector(NearVector.of(Target.vector(vector)), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(float[] vector, + Function> nv, + Function> fn) { + return nearVector(NearVector.of(Target.vector(vector), nv), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(float[][] vector, Function> fn) { + return nearVector(NearVector.of(Target.vector(vector)), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(float[][] vector, + Function> nv, + Function> fn) { + return nearVector(NearVector.of(Target.vector(vector), nv), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(NearVectorTarget searchTarget, + Function> fn) { + return nearVector(NearVector.of(searchTarget), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param searchTarget Query target. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(NearVectorTarget searchTarget, + Function> nv, + Function> fn) { + return nearVector(NearVector.of(searchTarget), fn); + } + + /** + * Aggregate results of a near vector query. + * + * @param filter Near vector query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVector(NearVector filter, + Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(Target.vector(vector)), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, + Function> nv, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(Target.vector(vector), nv), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(Target.vector(vector)), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param vector Query vector. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, + Function> nv, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(Target.vector(vector), nv), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(NearVectorTarget searchTarget, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param searchTarget Query target. + * @param nv Lambda expression for optional near vector parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(NearVectorTarget searchTarget, + Function> nv, + Function> fn, GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget, nv), fn, groupBy); + } + + /** + * Aggregate results of a near vector query. + * + * @param filter Near vector query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVector(NearVector filter, + Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearObject --------------------------------------------------------------- + + /** + * Aggregate results of a near object query. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearObject(String uuid, Function> fn) { + return nearObject(NearObject.of(uuid), fn); + } + + /** + * Aggregate results of a near object query. + * + * @param uuid Query object UUID. + * @param nobj Lambda expression for optional near object parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearObject(String uuid, Function> nobj, + Function> fn) { + return nearObject(NearObject.of(uuid, nobj), fn); + } + + /** + * Aggregate results of a near object query. + * + * @param filter Near object query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearObject(NearObject filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near object query. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, Function> fn, + GroupBy groupBy) { + return nearObject(NearObject.of(uuid), fn, groupBy); + } + + /** + * Aggregate results of a near object query. + * + * @param uuid Query object UUID. + * @param nobj Lambda expression for optional near object parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, Function> nobj, + Function> fn, GroupBy groupBy) { + return nearObject(NearObject.of(uuid, nobj), fn, groupBy); + } + + /** + * Aggregate results of a near object query. + * + * @param filter Near object query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearObject(NearObject filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearText ----------------------------------------------------------------- + + /** + * Aggregate results of a near text query. + * + * @param text Query string. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(String text, Function> fn) { + return nearText(NearText.of(text), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param concepts Query concepts. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(List concepts, Function> fn) { + return nearText(NearText.of(Target.text(concepts)), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(Target searchTarget, Function> fn) { + return nearText(NearText.of(searchTarget), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param text Query string. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(String text, + Function> nt, + Function> fn) { + return nearText(NearText.of(Target.text(List.of(text)), nt), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param concepts Query concepts. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(List concepts, + Function> nt, + Function> fn) { + return nearText(NearText.of(Target.text(concepts), nt), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param searchTarget Query target. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearText(Target searchTarget, + Function> nt, + Function> fn) { + return nearText(NearText.of(searchTarget, nt), fn); + } + + /** + * Aggregate results of a near text query. + * + * @param filter Near text query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(NearText filter, + Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near text query. + * + * @param text Query string. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(String text, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(text), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param concepts Query concepts. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(List concepts, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(Target.text(concepts)), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param text Query string. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(String text, + Function> nt, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(text, nt), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param concepts Query concepts. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(List concepts, + Function> nt, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(Target.text(concepts), nt), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param searchTarget Query target. + * @param nt Lambda expression for optional near text parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, + Function> nt, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(searchTarget, nt), fn, groupBy); + } + + /** + * Aggregate results of a near text query. + * + * @param filter Near text query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearText(NearText filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearImage ---------------------------------------------------------------- + + /** + * Aggregate results of a near image query. + * + * @param image Query image. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImage(String image, + Function> fn) { + return nearImage(NearImage.of(image), fn); + } + + /** + * Aggregate results of a near image query. + * + * @param image Query image. + * @param ni Lambda expression for optional near image parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImage(String image, + Function> ni, + Function> fn) { + return nearImage(NearImage.of(image, ni), fn); + } + + /** + * Aggregate results of a near image query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImage(Target searchTarget, + Function> fn) { + return nearImage(NearImage.of(searchTarget), fn); + } + + /** + * Aggregate results of a near image query. + * + * @param searchTarget Query target. + * @param ni Lambda expression for optional near image parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImage(Target searchTarget, + Function> ni, + Function> fn) { + return nearImage(NearImage.of(searchTarget, ni), fn); + } + + /** + * Aggregate results of a near image query. + * + * @param filter Near image query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImage(NearImage filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near image query. + * + * @param image Query image. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImage(String image, + Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(image), fn, groupBy); + } + + /** + * Aggregate results of a near image query. + * + * @param image Query image. + * @param ni Lambda expression for optional near image parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImage(String image, + Function> ni, + Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(image, ni), fn, groupBy); + } + + /** + * Aggregate results of a near image query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImage(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near image query. + * + * @param searchTarget Query target. + * @param ni Lambda expression for optional near image parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImage(Target searchTarget, + Function> ni, + Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget, ni), fn, groupBy); + } + + /** + * Aggregate results of a near image query. + * + * @param filter Near image query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImage(NearImage filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearAudio ---------------------------------------------------------------- + + /** + * Aggregate results of a near audio query. + * + * @param audio Query audio. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearAudio(String audio, Function> fn) { + return nearAudio(NearAudio.of(audio), fn); + } + + /** + * Aggregate results of a near audio query. + * + * @param audio Query audio. + * @param na Lambda expression for optional near audio parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearAudio(String audio, Function> na, + Function> fn) { + return nearAudio(NearAudio.of(audio, na), fn); + } + + /** + * Aggregate results of a near audio query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearAudio(Target searchTarget, + Function> fn) { + return nearAudio(NearAudio.of(searchTarget), fn); + } + + /** + * Aggregate results of a near audio query. + * + * @param searchTarget Query target. + * @param na Lambda expression for optional near audio parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearAudio(Target searchTarget, + Function> na, + Function> fn) { + return nearAudio(NearAudio.of(searchTarget, na), fn); + } + + /** + * Aggregate results of a near audio query. + * + * @param filter Near audio query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearAudio(NearAudio filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near audio query. + * + * @param audio Query audio. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearAudio(String audio, Function> fn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(audio), fn, groupBy); + } + + /** + * Aggregate results of a near audio query. + * + * @param audio Query audio. + * @param na Lambda expression for optional near audio parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearAudio(String audio, Function> na, + Function> fn, GroupBy groupBy) { + return nearAudio(NearAudio.of(audio, na), fn, groupBy); + } + + /** + * Aggregate results of a near audio query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearAudio(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near audio query. + * + * @param searchTarget Query target. + * @param na Lambda expression for optional near audio parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearAudio(Target searchTarget, + Function> na, + Function> fn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget, na), fn, groupBy); + } + + /** + * Aggregate results of a near audio query. + * + * @param filter Near audio query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearAudio(NearAudio filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearVideo ---------------------------------------------------------------- + + /** + * Aggregate results of a near video query. + * + * @param video Query video. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVideo(String video, Function> fn) { + return nearVideo(NearVideo.of(video), fn); + } + + /** + * Aggregate results of a near video query. + * + * @param video Query video. + * @param nv Lambda expression for optional near video parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVideo(String video, Function> nv, + Function> fn) { + return nearVideo(NearVideo.of(video, nv), fn); + } + + /** + * Aggregate results of a near video query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVideo(Target searchTarget, + Function> fn) { + return nearVideo(NearVideo.of(searchTarget), fn); + } + + /** + * Aggregate results of a near video query. + * + * @param searchTarget Query target. + * @param nv Lambda expression for optional near video parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVideo(Target searchTarget, + Function> nv, + Function> fn) { + return nearVideo(NearVideo.of(searchTarget, nv), fn); + } + + /** + * Aggregate results of a near video query. + * + * @param filter Near video query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearVideo(NearVideo filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near video query. + * + * @param video Query video. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVideo(String video, Function> fn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(video), fn, groupBy); + } + + /** + * Aggregate results of a near video query. + * + * @param video Query video. + * @param nv Lambda expression for optional near video parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVideo(String video, Function> nv, + Function> fn, GroupBy groupBy) { + return nearVideo(NearVideo.of(video, nv), fn, groupBy); + } + + /** + * Aggregate results of a near video query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVideo(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near video query. + * + * @param searchTarget Query target. + * @param nv Lambda expression for optional near video parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVideo(Target searchTarget, + Function> nv, + Function> fn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget, nv), fn, groupBy); + } + + /** + * Aggregate results of a near video query. + * + * @param filter Near video query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearVideo(NearVideo filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearThermal -------------------------------------------------------------- + + /** + * Aggregate results of a near thermal query. + * + * @param thermal Query thermal. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearThermal(String thermal, Function> fn) { + return nearThermal(NearThermal.of(thermal), fn); + } + + /** + * Aggregate results of a near thermal query. + * + * @param thermal Query thermal. + * @param nt Lambda expression for optional near thermal parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearThermal(String thermal, Function> nt, + Function> fn) { + return nearThermal(NearThermal.of(thermal, nt), fn); + } + + /** + * Aggregate results of a near thermal query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearThermal(Target searchTarget, + Function> fn) { + return nearThermal(NearThermal.of(searchTarget), fn); + } + + /** + * Aggregate results of a near thermal query. + * + * @param searchTarget Query target. + * @param nt Lambda expression for optional near thermal parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearThermal(Target searchTarget, + Function> nt, + Function> fn) { + return nearThermal(NearThermal.of(searchTarget, nt), fn); + } + + /** + * Aggregate results of a near thermal query. + * + * @param filter Near thermal query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearThermal(NearThermal filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near thermal query. + * + * @param thermal Query thermal. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearThermal(String thermal, Function> fn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal), fn, groupBy); + } + + /** + * Aggregate results of a near thermal query. + * + * @param thermal Query thermal. + * @param nt Lambda expression for optional near thermal parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearThermal(String thermal, Function> nt, + Function> fn, GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal, nt), fn, groupBy); + } + + /** + * Aggregate results of a near thermal query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearThermal(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near thermal query. + * + * @param searchTarget Query target. + * @param nt Lambda expression for optional near thermal parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearThermal(Target searchTarget, + Function> nt, + Function> fn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget, nt), fn, groupBy); + } + + /** + * Aggregate results of a near thermal query. + * + * @param filter Near thermal query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearThermal(NearThermal filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearDepth -------------------------------------------------------------- + + /** + * Aggregate results of a near depth query. + * + * @param depth Query depth. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearDepth(String depth, Function> fn) { + return nearDepth(NearDepth.of(depth), fn); + } + + /** + * Aggregate results of a near depth query. + * + * @param depth Query depth. + * @param nd Lambda expression for optional near depth parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearDepth(String depth, Function> nd, + Function> fn) { + return nearDepth(NearDepth.of(depth, nd), fn); + } + + /** + * Aggregate results of a near depth query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearDepth(Target searchTarget, + Function> fn) { + return nearDepth(NearDepth.of(searchTarget), fn); + } + + /** + * Aggregate results of a near depth query. + * + * @param searchTarget Query target. + * @param nd Lambda expression for optional near depth parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearDepth(Target searchTarget, + Function> nd, + Function> fn) { + return nearDepth(NearDepth.of(searchTarget, nd), fn); + } + + /** + * Aggregate results of a near depth query. + * + * @param filter Near depth query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearDepth(NearDepth filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near depth query. + * + * @param depth Query depth. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearDepth(String depth, Function> fn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(depth), fn, groupBy); + } + + /** + * Aggregate results of a near depth query. + * + * @param depth Query depth. + * @param nd Lambda expression for optional near depth parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearDepth(String depth, Function> nd, + Function> fn, GroupBy groupBy) { + return nearDepth(NearDepth.of(depth, nd), fn, groupBy); + } + + /** + * Aggregate results of a near depth query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearDepth(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near depth query. + * + * @param searchTarget Query target. + * @param nd Lambda expression for optional near depth parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearDepth(Target searchTarget, + Function> nd, + Function> fn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget, nd), fn, groupBy); + } + + /** + * Aggregate results of a near depth query. + * + * @param filter Near depth query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearDepth(NearDepth filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } + + // NearImu ------------------------------------------------------------------ + + /** + * Aggregate results of a near IMU query. + * + * @param imu Query IMU. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImu(String imu, Function> fn) { + return nearImu(NearImu.of(imu), fn); + } + + /** + * Aggregate results of a near IMU query. + * + * @param imu Query IMU. + * @param ni Lambda expression for optional near IMU parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImu(String imu, Function> ni, + Function> fn) { + return nearImu(NearImu.of(imu, ni), fn); + } + + /** + * Aggregate results of a near IMU query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImu(Target searchTarget, + Function> fn) { + return nearImu(NearImu.of(searchTarget), fn); + } + + /** + * Aggregate results of a near IMU query. + * + * @param searchTarget Query target. + * @param ni Lambda expression for optional near IMU parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImu(Target searchTarget, + Function> ni, + Function> fn) { + return nearImu(NearImu.of(searchTarget, ni), fn); + } + + /** + * Aggregate results of a near IMU query. + * + * @param filter Near IMU query request. + * @param fn Lambda expression for optional aggregation parameters. + * @return Aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @see AggregateResponse + */ + public ResponseT nearImu(NearImu filter, Function> fn) { + return performRequest(Aggregation.of(filter, fn)); + } + + /** + * Aggregate results of a near IMU query. + * + * @param imu Query IMU. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImu(String imu, Function> fn, + GroupBy groupBy) { + return nearImu(NearImu.of(imu), fn, groupBy); + } + + /** + * Aggregate results of a near IMU query. + * + * @param imu Query IMU. + * @param ni Lambda expression for optional near IMU parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImu(String imu, Function> ni, + Function> fn, GroupBy groupBy) { + return nearImu(NearImu.of(imu, ni), fn, groupBy); + } + + /** + * Aggregate results of a near IMU query. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImu(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget), fn, groupBy); + } + + /** + * Aggregate results of a near IMU query. + * + * @param searchTarget Query target. + * @param ni Lambda expression for optional near IMU parameters. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImu(Target searchTarget, + Function> ni, + Function> fn, + GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget, ni), fn, groupBy); + } + + /** + * Aggregate results of a near IMU query. + * + * @param filter Near IMU query request. + * @param fn Lambda expression for optional aggregation parameters. + * @param groupBy GroupBy clause. + * @return Grouped aggregation result. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see AggregateResponseGrouped + */ + public GroupedResponseT nearImu(NearImu filter, Function> fn, + GroupBy groupBy) { + return performRequest(Aggregation.of(filter, fn), groupBy); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractPropertyAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractPropertyAggregation.java new file mode 100644 index 000000000..d7da5480e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractPropertyAggregation.java @@ -0,0 +1,45 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.HashSet; +import java.util.Set; +import java.util.function.BiConsumer; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public abstract class AbstractPropertyAggregation implements PropertyAggregation { + private final String property; + private final Set> metrics; + + public AbstractPropertyAggregation(String property, Set> metrics) { + this.property = property; + this.metrics = metrics; + } + + @SuppressWarnings("unchecked") + public abstract static class Builder, SELF extends Builder> + implements ObjectBuilder { + // Required parameters. + protected final String property; + + protected final Set> metrics = new HashSet<>(); + + public Builder(String property) { + this.property = property; + } + + protected SELF addMetric(BiConsumer fn) { + metrics.add(Metric.of(fn)); + return (SELF) this; + } + } + + protected final void appendMetrics(AggregationT builder) { + metrics.forEach(metric -> metric.accept(builder)); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + req.setProperty(property); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregate.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregate.java new file mode 100644 index 000000000..a8de946b5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregate.java @@ -0,0 +1,36 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public final class Aggregate { + /** Prevent public initialization. */ + private Aggregate() { + } + + public static final PropertyAggregation text(String property, + Function> fn) { + return TextAggregation.of(property, fn); + } + + public static final PropertyAggregation integer(String property, + Function> fn) { + return IntegerAggregation.of(property, fn); + } + + public static final PropertyAggregation bool(String property, + Function> fn) { + return BooleanAggregation.of(property, fn); + } + + public static final PropertyAggregation date(String property, + Function> fn) { + return DateAggregation.of(property, fn); + } + + public static final PropertyAggregation number(String property, + Function> fn) { + return NumberAggregation.of(property, fn); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateObjectFilter.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateObjectFilter.java new file mode 100644 index 000000000..ee055a8fe --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateObjectFilter.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Builder; + +// TODO: move Near-, Hybrid, BM25 under client.collection.operators? With them implementing query.SearchOperator and aggregate.ObjectFilter +public interface AggregateObjectFilter { + void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req); + + static AggregateObjectFilter NONE = new AggregateObjectFilter() { + @Override + public void appendTo(Builder req) { + } + }; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java new file mode 100644 index 000000000..fa8290f64 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java @@ -0,0 +1,160 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.DateUtil; +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record AggregateRequest(Aggregation aggregation, GroupBy groupBy) { + + static Rpc rpc( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return Rpc.of( + request -> { + var message = WeaviateProtoAggregate.AggregateRequest.newBuilder(); + message.setCollection(collection.collectionName()); + request.aggregation.appendTo(message); + if (request.groupBy != null) { + request.groupBy.appendTo(message, collection.collectionName()); + } + if (defaults.tenant() != null) { + message.setTenant(defaults.tenant()); + } + return message.build(); + }, + reply -> { + Long totalCount = null; + Map properties = new HashMap<>(); + + // FIXME: check if group by was requested! + if (reply.hasSingleResult()) { + var single = reply.getSingleResult(); + totalCount = single.hasObjectsCount() ? single.getObjectsCount() : null; + properties = unmarshalAggregation(single.getAggregations()); + } + + var result = new AggregateResponse(properties, totalCount); + return result; + }, + () -> WeaviateBlockingStub::aggregate, + () -> WeaviateFutureStub::aggregate); + } + + static Rpc grouped( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var rpc = rpc(collection, defaults); + return Rpc.of(request -> rpc.marshal(request), reply -> { + var groups = new ArrayList>(); + if (reply.hasGroupedResults()) { + for (final var result : reply.getGroupedResults().getGroupsList()) { + + Long totalCount = result.hasObjectsCount() ? result.getObjectsCount() : null; + GroupedBy groupedBy = null; + var groupBy = result.getGroupedBy(); + var property = groupBy.getPathList().get(0); + + if (groupBy.hasInt()) { + groupedBy = new GroupedBy<>(property, groupBy.getInt()); + } else if (groupBy.hasText()) { + groupedBy = new GroupedBy<>(property, groupBy.getText()); + } else if (groupBy.hasBoolean()) { + groupedBy = new GroupedBy<>(property, groupBy.getBoolean()); + } else if (groupBy.hasNumber()) { + groupedBy = new GroupedBy<>(property, groupBy.getNumber()); + } else if (groupBy.hasTexts()) { + groupedBy = new GroupedBy<>(property, groupBy.getTexts().getValuesList().toArray(String[]::new)); + } else if (groupBy.hasInts()) { + groupedBy = new GroupedBy<>(property, groupBy.getInts().getValuesList().toArray(Long[]::new)); + } else if (groupBy.hasNumbers()) { + groupedBy = new GroupedBy<>(property, groupBy.getNumbers().getValuesList().toArray(Double[]::new)); + } else if (groupBy.hasBooleans()) { + groupedBy = new GroupedBy<>(property, groupBy.getBooleans().getValuesList().toArray(Boolean[]::new)); + } else { + throw new IllegalArgumentException(property + " data type is not supported"); + } + + var properties = unmarshalAggregation(result.getAggregations()); + var group = new AggregateResponseGroup<>(groupedBy, properties, totalCount); + groups.add(group); + + } + } + return new AggregateResponseGrouped(groups); + }, () -> rpc.method(), () -> rpc.methodAsync()); + + } + + private static Map unmarshalAggregation(WeaviateProtoAggregate.AggregateReply.Aggregations result) { + var properties = new HashMap(); + + for (var aggregation : result.getAggregationsList()) { + var property = aggregation.getProperty(); + Object value = null; + + if (aggregation.hasInt()) { + var metric = aggregation.getInt(); + value = new IntegerAggregation.Values( + metric.hasCount() ? metric.getCount() : null, + metric.hasMinimum() ? metric.getMinimum() : null, + metric.hasMaximum() ? metric.getMaximum() : null, + metric.hasMean() ? metric.getMean() : null, + metric.hasMedian() ? metric.getMedian() : null, + metric.hasMode() ? metric.getMode() : null, + metric.hasSum() ? metric.getSum() : null); + } else if (aggregation.hasText()) { + var metric = aggregation.getText(); + var topOccurrences = metric.hasTopOccurences() + ? metric.getTopOccurences().getItemsList() + .stream().map( + top -> new TextAggregation.TopOccurrence(top.getValue(), top.getOccurs())) + .toList() + : null; + value = new TextAggregation.Values( + metric.hasCount() ? metric.getCount() : null, + topOccurrences); + } else if (aggregation.hasBoolean()) { + var metric = aggregation.getBoolean(); + value = new BooleanAggregation.Values( + metric.hasCount() ? metric.getCount() : null, + metric.hasPercentageFalse() ? Float.valueOf((float) metric.getPercentageFalse()) : null, + metric.hasPercentageTrue() ? Float.valueOf((float) metric.getPercentageTrue()) : null, + metric.hasTotalFalse() ? metric.getTotalFalse() : null, + metric.hasTotalTrue() ? metric.getTotalTrue() : null); + } else if (aggregation.hasDate()) { + var metric = aggregation.getDate(); + value = new DateAggregation.Values( + metric.hasCount() ? metric.getCount() : null, + metric.hasMinimum() ? DateUtil.fromISO8601(metric.getMinimum()) : null, + metric.hasMaximum() ? DateUtil.fromISO8601(metric.getMaximum()) : null, + metric.hasMedian() ? DateUtil.fromISO8601(metric.getMedian()) : null, + metric.hasMode() ? DateUtil.fromISO8601(metric.getMode()) : null); + } else if (aggregation.hasNumber()) { + var metric = aggregation.getNumber(); + value = new NumberAggregation.Values( + metric.hasCount() ? metric.getCount() : null, + metric.hasMinimum() ? metric.getMinimum() : null, + metric.hasMaximum() ? metric.getMaximum() : null, + metric.hasMean() ? metric.getMean() : null, + metric.hasMedian() ? metric.getMedian() : null, + metric.hasMode() ? metric.getMode() : null, + metric.hasSum() ? metric.getSum() : null); + } else { + throw new IllegalArgumentException(property + " data type is not supported"); + } + + if (value != null) { + properties.put(property, value); + } + } + return properties; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponse.java new file mode 100644 index 000000000..fb4671338 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponse.java @@ -0,0 +1,57 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Map; +import java.util.function.Function; + +public record AggregateResponse(Map properties, Long totalCount) { + public boolean isText(String name) { + return properties.get(name) instanceof TextAggregation.Values; + } + + public TextAggregation.Values text(String name) { + checkPropertyType(name, this::isText, "TEXT"); + return (TextAggregation.Values) this.properties.get(name); + } + + public boolean isInteger(String name) { + return properties.get(name) instanceof IntegerAggregation.Values; + } + + public IntegerAggregation.Values integer(String name) { + checkPropertyType(name, this::isInteger, "INTEGER"); + return (IntegerAggregation.Values) this.properties.get(name); + } + + public boolean isBool(String name) { + return properties.get(name) instanceof BooleanAggregation.Values; + } + + public BooleanAggregation.Values bool(String name) { + checkPropertyType(name, this::isBool, "BOOLEAN"); + return (BooleanAggregation.Values) this.properties.get(name); + } + + public boolean isDate(String name) { + return properties.get(name) instanceof DateAggregation.Values; + } + + public DateAggregation.Values date(String name) { + checkPropertyType(name, this::isDate, "DATE"); + return (DateAggregation.Values) this.properties.get(name); + } + + public boolean isNumber(String name) { + return properties.get(name) instanceof NumberAggregation.Values; + } + + public NumberAggregation.Values number(String name) { + checkPropertyType(name, this::isNumber, "NUMBER"); + return (NumberAggregation.Values) this.properties.get(name); + } + + private void checkPropertyType(String name, Function check, String expected) { + if (!check.apply(name)) { + throw new IllegalStateException(name + "is not a " + expected + " property"); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGroup.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGroup.java new file mode 100644 index 000000000..8105b8830 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGroup.java @@ -0,0 +1,58 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Map; +import java.util.function.Function; + +public record AggregateResponseGroup(GroupedBy groupedBy, Map properties, + Long totalCount) { + public boolean isText(String name) { + return properties.get(name) instanceof TextAggregation.Values; + } + + public TextAggregation.Values text(String name) { + checkPropertyType(name, this::isText, "TEXT"); + return (TextAggregation.Values) this.properties.get(name); + } + + public boolean isInteger(String name) { + return properties.get(name) instanceof IntegerAggregation.Values; + } + + public IntegerAggregation.Values integer(String name) { + checkPropertyType(name, this::isInteger, "INTEGER"); + return (IntegerAggregation.Values) this.properties.get(name); + } + + public boolean isBool(String name) { + return properties.get(name) instanceof BooleanAggregation.Values; + } + + public BooleanAggregation.Values bool(String name) { + checkPropertyType(name, this::isBool, "BOOLEAN"); + return (BooleanAggregation.Values) this.properties.get(name); + } + + public boolean isDate(String name) { + return properties.get(name) instanceof DateAggregation.Values; + } + + public DateAggregation.Values date(String name) { + checkPropertyType(name, this::isDate, "DATE"); + return (DateAggregation.Values) this.properties.get(name); + } + + public boolean isNumber(String name) { + return properties.get(name) instanceof NumberAggregation.Values; + } + + public NumberAggregation.Values number(String name) { + checkPropertyType(name, this::isNumber, "NUMBER"); + return (NumberAggregation.Values) this.properties.get(name); + } + + private void checkPropertyType(String name, Function check, String expected) { + if (!check.apply(name)) { + throw new IllegalStateException(name + "is not a " + expected + " property"); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGrouped.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGrouped.java new file mode 100644 index 000000000..459fcf8f6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateResponseGrouped.java @@ -0,0 +1,7 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.List; + +public record AggregateResponseGrouped(List> groups) { + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregation.java new file mode 100644 index 000000000..019ff2922 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/Aggregation.java @@ -0,0 +1,118 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; + +public record Aggregation( + AggregateObjectFilter filter, + Filter whereFilter, + Integer objectLimit, + boolean includeTotalCount, + List returnMetrics) { + + public static Aggregation of() { + return of(AggregateObjectFilter.NONE, ObjectBuilder.identity()); + } + + public static Aggregation of(Function> fn) { + return of(AggregateObjectFilter.NONE, fn); + } + + public static Aggregation of(AggregateObjectFilter objectFilter, Function> fn) { + return fn.apply(new Builder(objectFilter)).build(); + } + + public Aggregation(Builder builder) { + this( + builder.objectFilter, + builder.whereFilter, + builder.objectLimit, + builder.includeTotalCount, + builder.metrics); + } + + public static class Builder implements ObjectBuilder { + private final AggregateObjectFilter objectFilter; + + public Builder(AggregateObjectFilter objectFilter) { + this.objectFilter = objectFilter; + } + + private Filter whereFilter; + private List metrics = new ArrayList<>(); + private Integer objectLimit; + private boolean includeTotalCount = false; + + public final Builder objectLimit(int limit) { + this.objectLimit = limit; + return this; + } + + public final Builder includeTotalCount(boolean include) { + this.includeTotalCount = include; + return this; + } + + /** + * Filter result set using traditional filtering operators: {@code eq}, + * {@code gte}, {@code like}, etc. + * Subsequent calls to {@link #filter} aggregate with an AND operator. + */ + public final Builder filters(Filter filter) { + this.whereFilter = this.whereFilter == null + ? filter + : Filter.and(this.whereFilter, filter); + return this; + } + + /** Combine several conditions using with an AND operator. */ + public final Builder filters(Filter... filters) { + Arrays.stream(filters).map(this::filters); + return this; + } + + @SafeVarargs + public final Builder metrics(PropertyAggregation... metrics) { + this.metrics = Arrays.asList(metrics); + return this; + } + + @Override + public Aggregation build() { + return new Aggregation(this); + } + } + + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (filter != null) { + filter.appendTo(req); + } + + if (includeTotalCount) { + req.setObjectsCount(true); + } + + if (objectLimit != null) { + req.setObjectLimit(objectLimit); + } + + if (whereFilter != null) { + var protoFilters = WeaviateProtoBase.Filters.newBuilder(); + whereFilter.appendTo(protoFilters); + req.setFilters(protoFilters); + } + + for (final var metric : returnMetrics) { + var aggregation = WeaviateProtoAggregate.AggregateRequest.Aggregation.newBuilder(); + metric.appendTo(aggregation); + req.addAggregations(aggregation); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/BooleanAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/BooleanAggregation.java new file mode 100644 index 000000000..223aad546 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/BooleanAggregation.java @@ -0,0 +1,68 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public class BooleanAggregation + extends AbstractPropertyAggregation { + + public BooleanAggregation(String property, + Set> metrics) { + super(property, metrics); + } + + public static BooleanAggregation of(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public BooleanAggregation(Builder builder) { + this(builder.property, builder.metrics); + } + + public static class Builder extends + AbstractPropertyAggregation.Builder { + + public Builder(String property) { + super(property); + } + + public final Builder count() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder::setCount); + } + + public final Builder percentageFalse() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder::setPercentageFalse); + } + + public final Builder percentageTrue() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder::setPercentageTrue); + } + + public final Builder totalFalse() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder::setTotalFalse); + } + + public final Builder totalTrue() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder::setTotalTrue); + } + + @Override + public final BooleanAggregation build() { + return new BooleanAggregation(this); + } + } + + public record Values(Long count, Float percentageFalse, Float percentageTrue, Long totalFalse, Long totalTrue) { + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + super.appendTo(req); + var bool = WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.newBuilder(); + appendMetrics(bool); + req.setBoolean(bool); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/DateAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/DateAggregation.java new file mode 100644 index 000000000..3dc8c4ac0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/DateAggregation.java @@ -0,0 +1,69 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.time.OffsetDateTime; +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public class DateAggregation + extends AbstractPropertyAggregation { + + public DateAggregation(String property, + Set> metrics) { + super(property, metrics); + } + + public static DateAggregation of(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public DateAggregation(Builder builder) { + this(builder.property, builder.metrics); + } + + public static class Builder extends + AbstractPropertyAggregation.Builder { + + public Builder(String property) { + super(property); + } + + public final Builder count() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder::setCount); + } + + public Builder min() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder::setMinimum); + } + + public Builder max() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder::setMaximum); + } + + public Builder median() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder::setMedian); + } + + public Builder mode() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder::setMode); + } + + @Override + public final DateAggregation build() { + return new DateAggregation(this); + } + } + + public record Values(Long count, OffsetDateTime min, OffsetDateTime max, OffsetDateTime median, OffsetDateTime mode) { + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + super.appendTo(req); + var date = WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.newBuilder(); + appendMetrics(date); + req.setDate(date); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupBy.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupBy.java new file mode 100644 index 000000000..e84b74a8f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupBy.java @@ -0,0 +1,50 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public record GroupBy(String property, Integer limit) { + public static final GroupBy property(String property) { + return property(property, ObjectBuilder.identity()); + } + + public static final GroupBy property(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public GroupBy(Builder builder) { + this(builder.property, builder.limit); + } + + public static class Builder implements ObjectBuilder { + private final String property; + + public Builder(String property) { + this.property = property; + } + + private Integer limit; + + public final Builder limit(int limit) { + this.limit = limit; + return this; + } + + @Override + public GroupBy build() { + return new GroupBy(this); + } + } + + void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req, String collection) { + if (limit != null) { + req.setLimit(limit); + } + + req.setGroupBy(WeaviateProtoAggregate.AggregateRequest.GroupBy.newBuilder() + .setCollection(collection) + .setProperty(property)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupedBy.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupedBy.java new file mode 100644 index 000000000..d17a0d218 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/GroupedBy.java @@ -0,0 +1,89 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Supplier; + +public record GroupedBy(String property, T value) { + public boolean isText() { + return value instanceof String; + } + + public String text() { + checkPropertyType(this::isText, "TEXT"); + return (String) value; + } + + public boolean isInteger() { + return value instanceof Long; + } + + public Long integer() { + checkPropertyType(this::isInteger, "INTEGER"); + return (Long) value; + } + + public boolean isBool() { + return value instanceof Boolean; + } + + public Boolean bool() { + checkPropertyType(this::isBool, "BOOLEAN"); + return (Boolean) value; + } + + public boolean isNumber() { + return value instanceof Double; + } + + public Double number() { + checkPropertyType(this::isNumber, "NUMBER"); + return (Double) value; + } + + public boolean isTextArray() { + return value instanceof String[]; + } + + @SuppressWarnings("unchecked") + public List textArray() { + checkPropertyType(this::isTextArray, "TEXT[]"); + return (List) Arrays.asList(value); + } + + public boolean isBoolArray() { + return value instanceof Boolean[]; + } + + @SuppressWarnings("unchecked") + public List boolArray() { + checkPropertyType(this::isBoolArray, "BOOLEAN[]"); + return (List) Arrays.asList(value); + } + + public boolean isIntegerArray() { + return value instanceof Long[]; + } + + @SuppressWarnings("unchecked") + public List integerArray() { + checkPropertyType(this::isIntegerArray, "INTEGER[]"); + return (List) Arrays.asList(value); + } + + public boolean isNumberArray() { + return value instanceof Double[]; + } + + @SuppressWarnings("unchecked") + public List numberArray() { + checkPropertyType(this::isNumberArray, "NUMBER[]"); + return (List) Arrays.asList(value); + } + + private void checkPropertyType(Supplier check, String expected) { + if (!check.get()) { + throw new IllegalStateException(property + "is not a " + expected + " property"); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/IntegerAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/IntegerAggregation.java new file mode 100644 index 000000000..9d674e4b3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/IntegerAggregation.java @@ -0,0 +1,76 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public class IntegerAggregation + extends AbstractPropertyAggregation { + + public IntegerAggregation(String property, + Set> metrics) { + super(property, metrics); + } + + public static IntegerAggregation of(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public IntegerAggregation(Builder builder) { + this(builder.property, builder.metrics); + } + + public static class Builder extends + AbstractPropertyAggregation.Builder { + + public Builder(String property) { + super(property); + } + + public final Builder count() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setCount); + } + + public Builder min() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setMinimum); + } + + public Builder max() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setMaximum); + } + + public Builder mean() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setMean); + } + + public Builder median() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setMedian); + } + + public Builder mode() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setMode); + } + + public Builder sum() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder::setSum); + } + + @Override + public final IntegerAggregation build() { + return new IntegerAggregation(this); + } + } + + public record Values(Long count, Long min, Long max, Double mean, Double median, Long mode, Long sum) { + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + super.appendTo(req); + var integer = WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.newBuilder(); + appendMetrics(integer); + req.setInt(integer); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/NumberAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/NumberAggregation.java new file mode 100644 index 000000000..55a4779ec --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/NumberAggregation.java @@ -0,0 +1,76 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public class NumberAggregation + extends AbstractPropertyAggregation { + + public NumberAggregation(String property, + Set> metrics) { + super(property, metrics); + } + + public static NumberAggregation of(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public NumberAggregation(Builder builder) { + this(builder.property, builder.metrics); + } + + public static class Builder extends + AbstractPropertyAggregation.Builder { + + public Builder(String property) { + super(property); + } + + public final Builder count() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setCount); + } + + public Builder min() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setMinimum); + } + + public Builder max() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setMaximum); + } + + public Builder mean() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setMean); + } + + public Builder median() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setMedian); + } + + public Builder mode() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setMode); + } + + public Builder sum() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder::setSum); + } + + @Override + public final NumberAggregation build() { + return new NumberAggregation(this); + } + } + + public record Values(Long count, Double min, Double max, Double mean, Double median, Double mode, Double sum) { + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + super.appendTo(req); + var number = WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.newBuilder(); + appendMetrics(number); + req.setNumber(number); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/PropertyAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/PropertyAggregation.java new file mode 100644 index 000000000..fee34b432 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/PropertyAggregation.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.function.BiConsumer; +import java.util.function.Consumer; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public interface PropertyAggregation { + void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req); + + interface Metric extends Consumer { + static Metric of(BiConsumer fn) { + return builder -> fn.accept(builder, true); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/TextAggregation.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/TextAggregation.java new file mode 100644 index 000000000..1d34afb7e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/TextAggregation.java @@ -0,0 +1,89 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.List; +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; + +public class TextAggregation + extends AbstractPropertyAggregation { + + private final Integer topOccurrencesCutoff; + + public TextAggregation(String property, + Set> metrics, + Integer topOccurrencesCutoff) { + super(property, metrics); + this.topOccurrencesCutoff = topOccurrencesCutoff; + } + + public static TextAggregation of(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + public TextAggregation(Builder builder) { + this(builder.property, builder.metrics, builder.topOccurrencesCutoff); + } + + public static class Builder extends + AbstractPropertyAggregation.Builder { + private Integer topOccurrencesCutoff; + + public Builder(String property) { + super(property); + } + + /** + * Include the number of occurrences (frequency count) for each top most + * occuring value in the results. + */ + public final Builder topOccurrencesCount() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder::setCount); + } + + public Builder type() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder::setType); + } + + /** + * Include the value of the top occurrences in the aggregation results. + */ + public Builder topOccurrencesValue() { + return addMetric(WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder::setTopOccurences); + } + + /** + * Set a minimum cutoff point after which groups should be discarded. + */ + public Builder minOccurrences(int cutoff) { + this.topOccurrencesCutoff = cutoff; + return topOccurrencesCount(); + } + + @Override + public final TextAggregation build() { + return new TextAggregation(this); + } + } + + public static record TopOccurrence(String value, long occurrenceCount) { + } + + public static record Values(Long count, List topOccurrences) { + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder req) { + super.appendTo(req); + + var text = WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.newBuilder(); + if (topOccurrencesCutoff != null) { + text.setTopOccurencesLimit(topOccurrencesCutoff); + } + + appendMetrics(text); + req.setText(text); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java new file mode 100644 index 000000000..ed6b0f234 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java @@ -0,0 +1,30 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateAggregateClient extends AbstractAggregateClient { + + public WeaviateAggregateClient( + CollectionDescriptor collection, + GrpcTransport transport, + CollectionHandleDefaults defaults) { + super(collection, transport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateAggregateClient(WeaviateAggregateClient c, CollectionHandleDefaults defaults) { + super(c, defaults); + } + + protected final AggregateResponse performRequest(Aggregation aggregation) { + var request = new AggregateRequest(aggregation, null); + return this.transport.performRequest(request, AggregateRequest.rpc(collection, defaults)); + } + + protected final AggregateResponseGrouped performRequest(Aggregation aggregation, GroupBy groupBy) { + var request = new AggregateRequest(aggregation, groupBy); + return this.transport.performRequest(request, AggregateRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java new file mode 100644 index 000000000..0b00513b3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java @@ -0,0 +1,33 @@ +package io.weaviate.client6.v1.api.collections.aggregate; + +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateAggregateClientAsync + extends AbstractAggregateClient, CompletableFuture> { + + public WeaviateAggregateClientAsync( + CollectionDescriptor collection, + GrpcTransport transport, + CollectionHandleDefaults defaults) { + super(collection, transport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateAggregateClientAsync(WeaviateAggregateClientAsync c, CollectionHandleDefaults defaults) { + super(c, defaults); + } + + protected final CompletableFuture performRequest(Aggregation aggregation) { + var request = new AggregateRequest(aggregation, null); + return this.transport.performRequestAsync(request, AggregateRequest.rpc(collection, defaults)); + } + + protected final CompletableFuture performRequest(Aggregation aggregation, GroupBy groupBy) { + var request = new AggregateRequest(aggregation, groupBy); + return this.transport.performRequestAsync(request, AggregateRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Collection.java b/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Collection.java new file mode 100644 index 000000000..4256c95ef --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Collection.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface Collection { + /** The name of the collection mapped by this class. */ + String value(); + + /** Collection description to add on creation. */ + String description() default ""; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Property.java b/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Property.java new file mode 100644 index 000000000..89275bc1d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/annotations/Property.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.api.collections.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.FIELD) +public @interface Property { + /** The name of the propety mapped by the record's field. */ + String value(); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/AddPropertyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/AddPropertyRequest.java new file mode 100644 index 000000000..3aab45dfa --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/AddPropertyRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.util.Collections; + +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record AddPropertyRequest(String collectionName, Property property) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "POST", + request -> "/schema/" + request.collectionName + "/properties", + request -> Collections.emptyMap(), + request -> JSON.serialize(request.property)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java new file mode 100644 index 000000000..5237fed26 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java @@ -0,0 +1,30 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record GetShardsRequest() { + + @SuppressWarnings("unchecked") + public static final Endpoint> endpoint( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return SimpleEndpoint.noBody( + request -> "GET", + request -> "/schema/" + collection.collectionName() + "/shards", + request -> defaults.tenant() != null + ? Map.of("tenant", defaults.tenant()) + : Collections.emptyMap(), + (statusCode, response) -> (List) JSON.deserialize(response, TypeToken.getParameterized( + List.class, Shard.class))); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/Shard.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/Shard.java new file mode 100644 index 000000000..f0797668f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/Shard.java @@ -0,0 +1,9 @@ +package io.weaviate.client6.v1.api.collections.config; + +import com.google.gson.annotations.SerializedName; + +public record Shard( + @SerializedName("name") String name, + @SerializedName("status") String status, + @SerializedName("vectorQueueSize") long vectorQueueSize) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/ShardStatus.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/ShardStatus.java new file mode 100644 index 000000000..bc5bb06d2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/ShardStatus.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.collections.config; + +import com.google.gson.annotations.SerializedName; + +public enum ShardStatus { + @SerializedName("READY") + READY, + @SerializedName("READONLY") + READONLY; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateCollectionRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateCollectionRequest.java new file mode 100644 index 000000000..ea79f8f7c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateCollectionRequest.java @@ -0,0 +1,165 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.InvertedIndex; +import io.weaviate.client6.v1.api.collections.MultiTenancy; +import io.weaviate.client6.v1.api.collections.ObjectTtl; +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.Replication; +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record UpdateCollectionRequest(CollectionConfig updated, CollectionConfig original) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "PUT", + request -> "/schema/" + request.updated.collectionName(), + request -> Collections.emptyMap(), + request -> { + var json = JSON.serialize(request.updated); + + // Workaround: when doing updates, the server *insists* that + // "skipDefaultQuantization" property remains unchanged for each vector, + // even in cases when it is irrelevant [shrug]. + // To mitigate that we will set that field to its original value for all + // vectors which were present in the original configuration. + var jsonObject = JSON.toJsonElement(json).getAsJsonObject(); + var vectorsAny = jsonObject.get("vectorConfig"); + if (request.original.vectors() != null && !request.original.vectors().isEmpty() + && vectorsAny != null && vectorsAny.isJsonObject()) { + var vectors = vectorsAny.getAsJsonObject(); + for (var origVector : request.original.vectors().entrySet()) { + var vectorName = origVector.getKey(); + var origQuantization = origVector.getValue().quantization(); + if (vectors.has(vectorName) && origQuantization != null) { + vectors + .get(vectorName).getAsJsonObject() + .get("vectorIndexConfig").getAsJsonObject() + .addProperty(Quantization.Kind.UNCOMPRESSED.jsonValue(), origQuantization.isUncompressed()); + } + } + + json = jsonObject.toString(); + } + + return json; + }); + + public static UpdateCollectionRequest of(CollectionConfig original, + Function> fn) { + return fn.apply(new Builder(original)).build(); + } + + public UpdateCollectionRequest(Builder builder) { + this(builder.newCollection.build(), builder.currentCollection); + } + + public static class Builder implements ObjectBuilder { + // For updating property descriptions + private final CollectionConfig currentCollection; + // Builder for the updated collection config. + private final CollectionConfig.Builder newCollection; + + public Builder(CollectionConfig currentCollection) { + this.currentCollection = currentCollection; + this.newCollection = currentCollection.edit(); + } + + public Builder description(String description) { + this.newCollection.description(description); + return this; + } + + public Builder propertyDescription(String propertyName, String description) { + for (var property : currentCollection.properties()) { + if (property.propertyName().equals(propertyName)) { + var newProperty = property.edit(p -> p.description(description)); + this.newCollection.properties(newProperty); + break; + } + } + return this; + } + + public Builder replication(Replication replication) { + this.newCollection.replication(replication); + return this; + } + + public Builder replication(Function> fn) { + this.newCollection.replication(fn); + return this; + } + + public Builder invertedIndex(InvertedIndex invertedIndex) { + this.newCollection.invertedIndex(invertedIndex); + return this; + } + + public Builder invertedIndex(Function> fn) { + this.newCollection.invertedIndex(fn); + return this; + } + + public Builder objectTtl(ObjectTtl objectTtl) { + this.newCollection.objectTtl(objectTtl); + return this; + } + + public Builder objectTtl(Function> fn) { + this.newCollection.objectTtl(fn); + return this; + } + + public Builder rerankerModules(Reranker... rerankerModules) { + this.newCollection.rerankerModules(rerankerModules); + return this; + } + + public Builder rerankerModules(List rerankerModules) { + this.newCollection.rerankerModules(rerankerModules); + return this; + } + + public Builder generativeModule(Generative generativeModule) { + this.newCollection.generativeModule(generativeModule); + return this; + } + + public final Builder vectorConfig(Map vectors) { + this.newCollection.vectorConfig(vectors); + return this; + } + + @SafeVarargs + public final Builder vectorConfig(Map.Entry... vectors) { + this.newCollection.vectorConfig(vectors); + return this; + } + + public Builder multiTenancy(MultiTenancy multiTenancy) { + this.newCollection.multiTenancy(multiTenancy); + return this; + } + + public Builder multiTenancy(Function> fn) { + this.newCollection.multiTenancy(fn); + return this; + } + + @Override + public UpdateCollectionRequest build() { + return new UpdateCollectionRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateShardStatusRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateShardStatusRequest.java new file mode 100644 index 000000000..53415c202 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/UpdateShardStatusRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.util.Collections; +import java.util.Map; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record UpdateShardStatusRequest(String collection, String shard, ShardStatus status) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + request -> "PUT", + request -> "/schema/" + request.collection + "/shards/" + request.shard, + request -> Collections.emptyMap(), + request -> JSON.serialize(Map.of("status", request.status))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java new file mode 100644 index 000000000..33d50fb01 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java @@ -0,0 +1,82 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateConfigClient { + private final RestTransport restTransport; + private final WeaviateCollectionsClient collectionsClient; + + private final CollectionDescriptor collection; + private final CollectionHandleDefaults defaults; + + public WeaviateConfigClient( + CollectionDescriptor collection, + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.restTransport = restTransport; + this.collectionsClient = new WeaviateCollectionsClient(restTransport, grpcTransport); + + this.collection = collection; + this.defaults = defaults; + } + + /** Copy constructor that sets new defaults. */ + public WeaviateConfigClient(WeaviateConfigClient c, CollectionHandleDefaults defaults) { + this.restTransport = c.restTransport; + this.collectionsClient = c.collectionsClient; + this.collection = c.collection; + this.defaults = defaults; + } + + public Optional get() throws IOException { + return collectionsClient.getConfig(collection.collectionName()); + } + + public void addProperty(Property property) throws IOException { + this.restTransport.performRequest(new AddPropertyRequest(collection.collectionName(), property), + AddPropertyRequest._ENDPOINT); + } + + public void addReference(String propertyName, String... dataTypes) throws IOException { + this.addProperty(ReferenceProperty.to(propertyName, dataTypes).toProperty()); + } + + public void update(Function> fn) + throws IOException { + var thisCollection = get().orElseThrow(); // TODO: use descriptive error + this.restTransport.performRequest(UpdateCollectionRequest.of(thisCollection, fn), + UpdateCollectionRequest._ENDPOINT); + } + + public List getShards() throws IOException { + return this.restTransport.performRequest(null, GetShardsRequest.endpoint(collection, defaults)); + } + + public List updateShards(ShardStatus status, String... shards) throws IOException { + return updateShards(status, Arrays.asList(shards)); + } + + public List updateShards(ShardStatus status, List shards) throws IOException { + for (var shard : shards) { + this.restTransport.performRequest( + new UpdateShardStatusRequest(collection.collectionName(), shard, status), + UpdateShardStatusRequest._ENDPOINT); + } + return getShards(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java new file mode 100644 index 000000000..1c5d8f169 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java @@ -0,0 +1,85 @@ +package io.weaviate.client6.v1.api.collections.config; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateConfigClientAsync { + private final RestTransport restTransport; + private final WeaviateCollectionsClientAsync collectionsClient; + + private final CollectionDescriptor collection; + private final CollectionHandleDefaults defaults; + + public WeaviateConfigClientAsync( + CollectionDescriptor collection, + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.restTransport = restTransport; + this.collectionsClient = new WeaviateCollectionsClientAsync(restTransport, grpcTransport); + + this.collection = collection; + this.defaults = defaults; + } + + /** Copy constructor that sets new defaults. */ + public WeaviateConfigClientAsync(WeaviateConfigClientAsync c, CollectionHandleDefaults defaults) { + this.restTransport = c.restTransport; + this.collectionsClient = c.collectionsClient; + this.collection = c.collection; + this.defaults = defaults; + } + + public CompletableFuture> get() throws IOException { + return collectionsClient.getConfig(collection.collectionName()); + } + + public CompletableFuture addProperty(Property property) throws IOException { + return this.restTransport.performRequestAsync(new AddPropertyRequest(collection.collectionName(), property), + AddPropertyRequest._ENDPOINT); + } + + public CompletableFuture addReference(String name, String... dataTypes) throws IOException { + return this.addProperty(ReferenceProperty.to(name, dataTypes).toProperty()); + } + + public CompletableFuture update( + Function> fn) throws IOException { + return get().thenCompose(maybeCollection -> { + var thisCollection = maybeCollection.orElseThrow(); + return this.restTransport.performRequestAsync(UpdateCollectionRequest.of(thisCollection, fn), + UpdateCollectionRequest._ENDPOINT); + }); + } + + public CompletableFuture> getShards() { + return this.restTransport.performRequestAsync(null, GetShardsRequest.endpoint(collection, defaults)); + } + + public CompletableFuture> updateShards(ShardStatus status, String... shards) throws IOException { + return updateShards(status, Arrays.asList(shards)); + } + + public CompletableFuture> updateShards(ShardStatus status, List shards) throws IOException { + var updates = shards.stream().map( + shard -> this.restTransport.performRequestAsync( + new UpdateShardStatusRequest(collection.collectionName(), shard, status), + UpdateShardStatusRequest._ENDPOINT)) + .toArray(CompletableFuture[]::new); + return CompletableFuture.allOf(updates).thenCompose(__ -> getShards()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/BatchReference.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/BatchReference.java new file mode 100644 index 000000000..a83652be5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/BatchReference.java @@ -0,0 +1,92 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.io.IOException; +import java.util.Arrays; + +import com.google.gson.TypeAdapter; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.WeaviateObject; + +public record BatchReference(String fromCollection, String fromProperty, String fromUuid, ObjectReference reference) { + + public static BatchReference[] objects(WeaviateObject fromObject, String fromProperty, + WeaviateObject... toObjects) { + return Arrays.stream(toObjects) + .map(to -> new BatchReference( + fromObject.collection(), fromProperty, fromObject.uuid(), + ObjectReference.object(to))) + .toArray(BatchReference[]::new); + } + + public static BatchReference[] uuids(WeaviateObject fromObject, String fromProperty, + String... toUuids) { + return Arrays.stream(toUuids) + .map(to -> new BatchReference( + fromObject.collection(), fromProperty, fromObject.uuid(), + ObjectReference.uuid(to))) + .toArray(BatchReference[]::new); + } + + public static final TypeAdapter TYPE_ADAPTER = new TypeAdapter() { + + @Override + public void write(JsonWriter out, BatchReference value) throws IOException { + out.beginObject(); + + out.name("from"); + out.value(ObjectReference.toBeacon(value.fromCollection, value.fromProperty, value.fromUuid)); + + out.name("to"); + out.value(ObjectReference.toBeacon(value.reference.collection(), value.reference.uuid())); + + out.endObject(); + } + + @Override + public BatchReference read(JsonReader in) throws IOException { + String fromCollection = null; + String fromProperty = null; + String fromUuid = null; + ObjectReference toReference = null; + + in.beginObject(); + while (in.hasNext()) { + switch (in.nextName()) { + + case "from": { + var beacon = in.nextString(); + beacon = beacon.replaceFirst("weaviate://localhost/", ""); + + var parts = beacon.split("/"); + fromCollection = parts[0]; + fromUuid = parts[1]; + fromProperty = parts[2]; + break; + } + + case "to": { + String collection = null; + String id = null; + + var beacon = in.nextString(); + beacon = beacon.replaceFirst("weaviate://localhost/", ""); + if (beacon.contains("/")) { + var parts = beacon.split("/"); + collection = parts[0]; + id = parts[1]; + } else { + id = beacon; + } + toReference = new ObjectReference(collection, id); + break; + } + } + } + in.endObject(); + + return new BatchReference(fromCollection, fromProperty, fromUuid, toReference); + } + }.nullSafe(); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java new file mode 100644 index 000000000..2fff8681a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java @@ -0,0 +1,106 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.ByteStringUtil; +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record DeleteManyRequest(Filter filters, Boolean verbose, Boolean dryRun) { + + public static Rpc rpc( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return Rpc.of( + request -> { + var message = WeaviateProtoBatchDelete.BatchDeleteRequest.newBuilder(); + message.setCollection(collection.collectionName()); + + if (request.verbose != null) { + message.setVerbose(request.verbose); + } + if (request.dryRun != null) { + message.setDryRun(request.dryRun); + } + if (defaults.tenant() != null) { + message.setTenant(defaults.tenant()); + } + if (defaults.consistencyLevel() != null) { + defaults.consistencyLevel().appendTo(message); + } + + var filters = WeaviateProtoBase.Filters.newBuilder(); + request.filters.appendTo(filters); + message.setFilters(filters); + + return message.build(); + }, + reply -> { + var objects = reply.getObjectsList() + .stream() + .map(obj -> new DeleteManyResponse.DeletedObject( + ByteStringUtil.decodeUuid(obj.getUuid()), + obj.getSuccessful(), + obj.getError())) + .toList(); + + return new DeleteManyResponse( + reply.getTook(), + reply.getFailed(), + reply.getMatches(), + reply.getSuccessful(), + objects); + }, + () -> WeaviateBlockingStub::batchDelete, + () -> WeaviateFutureStub::batchDelete); + } + + public static DeleteManyRequest of(Filter filters) { + return of(filters, ObjectBuilder.identity()); + } + + public DeleteManyRequest(Builder builder) { + this( + builder.filters, + builder.verbose, + builder.dryRun); + } + + public static DeleteManyRequest of(Filter filters, Function> fn) { + return fn.apply(new Builder(filters)).build(); + } + + public static class Builder implements ObjectBuilder { + // Required request parameters; + private final Filter filters; + + private Boolean verbose; + private Boolean dryRun; + + public Builder(Filter filters) { + this.filters = filters; + } + + public Builder verbose(boolean verbose) { + this.verbose = verbose; + return this; + } + + public Builder dryRun(boolean dryRun) { + this.dryRun = dryRun; + return this; + } + + @Override + public DeleteManyRequest build() { + return new DeleteManyRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyResponse.java new file mode 100644 index 000000000..5df7fd93a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyResponse.java @@ -0,0 +1,9 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.List; + +public record DeleteManyResponse(float took, long failed, long matches, long successful, List objects) { + + public static record DeletedObject(String uuid, boolean successful, String error) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java new file mode 100644 index 000000000..2788566a9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java @@ -0,0 +1,18 @@ +package io.weaviate.client6.v1.api.collections.data; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; + +public record DeleteObjectRequest(String uuid) { + + public static final Endpoint endpoint( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return BooleanEndpoint.noBody( + request -> "DELETE", + request -> "/objects/" + collection.collectionName() + "/" + request.uuid, + request -> defaults.queryParameters()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java new file mode 100644 index 000000000..11df4e8b9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java @@ -0,0 +1,333 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.time.OffsetDateTime; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.MapUtil; +import io.weaviate.client6.v1.internal.grpc.ByteStringUtil; +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record InsertManyRequest(List> objects) { + + @SafeVarargs + public InsertManyRequest(WeaviateObject... objects) { + this(Arrays.asList(objects)); + } + + @SuppressWarnings("unchecked") + @SafeVarargs + public static final InsertManyRequest of(PropertiesT... properties) { + var objects = Arrays.stream(properties) + .map(p -> (WeaviateObject) WeaviateObject.of(obj -> obj.properties(p))) + .toList(); + return new InsertManyRequest<>(objects); + } + + public static Rpc, WeaviateProtoBatch.BatchObjectsRequest, InsertManyResponse, WeaviateProtoBatch.BatchObjectsReply> rpc( + List> insertObjects, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return Rpc.insert( + request -> { + var message = WeaviateProtoBatch.BatchObjectsRequest.newBuilder(); + + var batch = request.objects.stream().map(obj -> { + var batchObject = WeaviateProtoBatch.BatchObject.newBuilder(); + buildObject(batchObject, obj, collection, defaults); + return batchObject.build(); + }).toList(); + + message.addAllObjects(batch); + + if (defaults.consistencyLevel() != null) { + defaults.consistencyLevel().appendTo(message); + } + return message.build(); + }, + response -> { + var insertErrors = response.getErrorsList(); + + var responses = new ArrayList(insertObjects.size()); + var errors = new ArrayList(insertErrors.size()); + var uuids = new ArrayList(); + + var failed = MapUtil.collect( + insertErrors.stream(), + err -> err.getIndex(), + err -> err.getError()); + + var iter = insertObjects.listIterator(); + while (iter.hasNext()) { + var idx = iter.nextIndex(); + var next = iter.next(); + + var uuid = next.uuid(); + if (failed.containsKey(idx)) { + var err = failed.get(idx); + errors.add(err); + responses.add(new InsertManyResponse.InsertObject(uuid, false, err)); + } else { + uuids.add(uuid); + responses.add(new InsertManyResponse.InsertObject(uuid, true, null)); + } + } + + return new InsertManyResponse(response.getTook(), responses, uuids, errors); + }, + () -> WeaviateBlockingStub::batchObjects, + () -> WeaviateFutureStub::batchObjects); + } + + public static void buildObject(WeaviateProtoBatch.BatchObject.Builder object, + WeaviateObject insert, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + object.setCollection(collection.collectionName()); + + if (insert.uuid() != null) { + object.setUuid(insert.uuid()); + } + + if (insert.vectors() != null) { + var vectors = insert.vectors().asMap() + .entrySet().stream().map(entry -> { + var value = entry.getValue(); + var vector = WeaviateProtoBase.Vectors.newBuilder() + .setName(entry.getKey()); + + if (value instanceof float[] single) { + vector.setType(VectorType.VECTOR_TYPE_SINGLE_FP32); + vector.setVectorBytes(ByteStringUtil.encodeVectorSingle(single)); + } else if (value instanceof float[][] multi) { + vector.setVectorBytes(ByteStringUtil.encodeVectorMulti(multi)); + vector.setType(VectorType.VECTOR_TYPE_MULTI_FP32); + } + + return vector.build(); + }).toList(); + object.addAllVectors(vectors); + } + if (defaults.tenant() != null) { + object.setTenant(defaults.tenant()); + } + + var singleRef = new ArrayList(); + var multiRef = new ArrayList(); + + if (insert.references() != null) { + insert.references().entrySet().stream().forEach(entry -> { + var references = entry.getValue(); + + // dyma: How are we supposed to know if the reference + // is single- or multi-target? + for (var ref : references) { + if (ref.collection() == null) { + singleRef.add(WeaviateProtoBatch.BatchObject.SingleTargetRefProps.newBuilder() + .addUuids(ref.uuid()) + .setPropName(entry.getKey()).build()); + } else { + multiRef.add(WeaviateProtoBatch.BatchObject.MultiTargetRefProps.newBuilder() + .setTargetCollection(ref.collection()).addUuids(ref.uuid()) + .setPropName(entry.getKey()).build()); + } + } + }); + } + + var properties = WeaviateProtoBatch.BatchObject.Properties.newBuilder() + .addAllSingleTargetRefProps(singleRef) + .addAllMultiTargetRefProps(multiRef); + + if (insert.properties() != null) { + var nonRef = marshalStruct(collection.propertiesReader(insert.properties()) + .readProperties()); + properties.setNonRefProperties(nonRef); + } + object.setProperties(properties); + } + + @SuppressWarnings("unchecked") + private static com.google.protobuf.Value marshalValue(Object value) { + var protoValue = com.google.protobuf.Value.newBuilder(); + + if (value == null) { + return null; + } + + if (value instanceof String v) { + protoValue.setStringValue(v); + } else if (value instanceof UUID v) { + protoValue.setStringValue(v.toString()); + } else if (value instanceof OffsetDateTime v) { + protoValue.setStringValue(v.toString()); + } else if (value instanceof Boolean v) { + protoValue.setBoolValue(v.booleanValue()); + } else if (value instanceof Number v) { + protoValue.setNumberValue(v.doubleValue()); + } else if (value instanceof PhoneNumber phone) { + var phoneProto = com.google.protobuf.Struct.newBuilder(); + if (phone.rawInput() != null) { + var input = com.google.protobuf.Value.newBuilder().setStringValue(phone.rawInput()); + phoneProto.putFields("input", input.build()); + } + if (phone.defaultCountry() != null) { + var defaultCountry = com.google.protobuf.Value.newBuilder().setStringValue(phone.defaultCountry()); + phoneProto.putFields("defaultCountry", defaultCountry.build()); + } + protoValue.setStructValue(phoneProto); + } else if (value instanceof GeoCoordinates geo) { + var latitude = com.google.protobuf.Value.newBuilder().setNumberValue(geo.latitude()); + var longitude = com.google.protobuf.Value.newBuilder().setNumberValue(geo.longitude()); + protoValue.setStructValue(com.google.protobuf.Struct.newBuilder() + .putFields("latitude", latitude.build()) + .putFields("longitude", longitude.build())); + } else if (value instanceof List v) { + protoValue.setListValue( + com.google.protobuf.ListValue.newBuilder() + .addAllValues(v.stream() + .map(listValue -> { + var protoListValue = com.google.protobuf.Value.newBuilder(); + if (listValue instanceof String lv) { + protoListValue.setStringValue(lv); + } else if (listValue instanceof UUID lv) { + protoListValue.setStringValue(lv.toString()); + } else if (listValue instanceof OffsetDateTime lv) { + protoListValue.setStringValue(lv.toString()); + } else if (listValue instanceof Boolean lv) { + protoListValue.setBoolValue(lv); + } else if (listValue instanceof Number lv) { + protoListValue.setNumberValue(lv.doubleValue()); + } else if (listValue instanceof Map properties) { + protoListValue.setStructValue(marshalStruct((Map) properties)); + } else if (listValue instanceof Record r) { + CollectionDescriptor recordDescriptor = (CollectionDescriptor) CollectionDescriptor + .ofClass(r.getClass()); + var properties = recordDescriptor.propertiesReader(r).readProperties(); + protoListValue.setStructValue(marshalStruct(properties)); + } else { + throw new IllegalArgumentException("data type " + value.getClass() + " is not supported"); + } + return protoListValue.build(); + }) + .toList())); + + } else if (value.getClass().isArray()) { + List values; + + if (value instanceof String[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setStringValue(lv).build()).toList(); + } else if (value instanceof UUID[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setStringValue(lv.toString()).build()).toList(); + } else if (value instanceof OffsetDateTime[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setStringValue(lv.toString()).build()).toList(); + } else if (value instanceof Boolean[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setBoolValue(lv).build()).toList(); + } else if (value instanceof boolean[] v) { + values = new ArrayList<>(); + for (boolean b : v) { + values.add(com.google.protobuf.Value.newBuilder().setBoolValue(b).build()); + } + } else if (value instanceof short[] v) { + values = new ArrayList<>(); + for (short s : v) { + values.add(com.google.protobuf.Value.newBuilder().setNumberValue(s).build()); + } + } else if (value instanceof int[] v) { + values = Arrays.stream(v).boxed() + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof long[] v) { + values = Arrays.stream(v).boxed() + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof float[] v) { + values = new ArrayList<>(); + for (float s : v) { + values.add(com.google.protobuf.Value.newBuilder().setNumberValue(s).build()); + } + } else if (value instanceof double[] v) { + values = Arrays.stream(v).boxed() + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Short[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Integer[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Long[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Float[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Double[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder().setNumberValue(lv).build()).toList(); + } else if (value instanceof Map[] v) { + values = Arrays.stream(v) + .map(lv -> com.google.protobuf.Value.newBuilder() + .setStructValue(marshalStruct((Map) lv)) + .build()) + .toList(); + } else if (value instanceof Record[] v) { + values = Arrays.stream(v) + .map(lv -> { + // Get the descriptor for each iteration in case the array is heterogenous. + final CollectionDescriptor recordDescriptor = (CollectionDescriptor) CollectionDescriptor + .ofClass(lv.getClass()); + var properties = recordDescriptor.propertiesReader(lv).readProperties(); + return com.google.protobuf.Value.newBuilder() + .setStructValue(marshalStruct(properties)) + .build(); + }) + .toList(); + } else { + throw new IllegalArgumentException("array type " + value.getClass() + " is not supported"); + } + + protoValue.setListValue(com.google.protobuf.ListValue.newBuilder() + .addAllValues(values) + .build()); + } else if (value instanceof Map properties) { + protoValue.setStructValue(marshalStruct((Map) properties)); + } else if (value instanceof Record r) { + CollectionDescriptor recordDescriptor = (CollectionDescriptor) CollectionDescriptor + .ofClass(r.getClass()); + var properties = recordDescriptor.propertiesReader(r).readProperties(); + protoValue.setStructValue(marshalStruct(properties)); + } else { + throw new IllegalArgumentException("data type " + value.getClass() + " is not supported"); + } + + return protoValue.build(); + } + + private static com.google.protobuf.Struct marshalStruct(Map properties) { + var struct = com.google.protobuf.Struct.newBuilder(); + properties.entrySet().stream() + .forEach(entry -> { + var nestedValue = marshalValue(entry.getValue()); + if (nestedValue == null) { + return; + } + struct.putFields((String) entry.getKey(), nestedValue); + }); + return struct.build(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyResponse.java new file mode 100644 index 000000000..ee41cc458 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyResponse.java @@ -0,0 +1,9 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.List; + +public record InsertManyResponse(float took, List responses, List uuids, List errors) { + + public static record InsertObject(String uuid, boolean successful, String error) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java new file mode 100644 index 000000000..8588eb760 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java @@ -0,0 +1,57 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.Collections; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record InsertObjectRequest(WeaviateObject object) { + + @SuppressWarnings("unchecked") + public static final Endpoint, WeaviateObject> endpoint( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + + final var typeToken = (TypeToken>) TypeToken + .getParameterized(WeaviateObject.class, collection.typeToken().getType()); + + return new SimpleEndpoint<>( + request -> "POST", + request -> "/objects/", + request -> defaults.consistencyLevel() != null + ? Map.of("consistency_level", defaults.consistencyLevel()) + : Collections.emptyMap(), + request -> JSON.serialize( + new WeaviateObject<>( + request.object.uuid(), + collection.collectionName(), + defaults.tenant(), + request.object.properties(), + request.object.vectors(), + request.object.createdAt(), + request.object.lastUpdatedAt(), + null, // no queryMetadata no insert + request.object.references()), + typeToken), + (statusCode, response) -> JSON.deserialize(response, typeToken)); + } + + static InsertObjectRequest of(PropertiesT properties) { + return of(properties, ObjectBuilder.identity()); + } + + static InsertObjectRequest of( + PropertiesT properties, + Function, ObjectBuilder>> fn) { + return new InsertObjectRequest<>(WeaviateObject.of(ObjectBuilder.partial(fn, b -> b.properties(properties)))); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ObjectReference.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ObjectReference.java new file mode 100644 index 000000000..bb6a0f27e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ObjectReference.java @@ -0,0 +1,125 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Map; + +import com.google.gson.TypeAdapter; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonToken; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.Reference; +import io.weaviate.client6.v1.api.collections.WeaviateObject; + +public record ObjectReference(String collection, String uuid) implements Reference { + + @Override + public WeaviateObject> asWeaviateObject() { + throw new IllegalStateException("cannot convert to WeaviateObject"); + } + + /** + * Create reference to a single object by UUID. + *

+ * Weaviate will search each of the existing collections to identify + * the objects before inserting the references, so this may include + * some performance overhead. + */ + public static ObjectReference uuid(String uuid) { + return new ObjectReference(null, uuid); + } + + /** + * Create reference to objects by their UUIDs. + *

+ * Weaviate will search each of the existing collections to identify + * the objects before inserting the references, so this may include + * some performance overhead. + */ + public static ObjectReference[] uuids(String... uuids) { + return Arrays.stream(uuids) + .map(ObjectReference::uuid) + .toArray(ObjectReference[]::new); + } + + /** Create references to single {@link WeaviateObject}. */ + public static ObjectReference object(WeaviateObject object) { + return new ObjectReference(object.collection(), object.uuid()); + } + + /** Create references to multiple {@link WeaviateObject}. */ + public static ObjectReference[] objects(WeaviateObject... objects) { + return Arrays.stream(objects) + .map(o -> new ObjectReference(o.collection(), o.uuid())) + .toArray(ObjectReference[]::new); + } + + /** Create a reference to an single object in a collection by its UUID. */ + public static ObjectReference collection(String collection, String uuid) { + return new ObjectReference(collection, uuid); + } + + /** Create references to objects in a collection by their UUIDs. */ + public static ObjectReference[] collection(String collection, String... uuids) { + return Arrays.stream(uuids) + .map(uuid -> new ObjectReference(collection, uuid)) + .toArray(ObjectReference[]::new); + } + + public static String toBeacon(String collection, String uuid) { + return toBeacon(collection, null, uuid); + } + + public static String toBeacon(String collection, String property, String uuid) { + var beacon = "weaviate://localhost"; + if (collection != null) { + beacon += "/" + collection; + } + beacon += "/" + uuid; + if (property != null) { + beacon += "/" + property; + } + return beacon; + } + + public static final TypeAdapter TYPE_ADAPTER = new TypeAdapter() { + + @Override + public void write(JsonWriter out, ObjectReference value) throws IOException { + out.beginObject(); + out.name("beacon"); + out.value(toBeacon(value.collection(), value.uuid())); + out.endObject(); + } + + @Override + public ObjectReference read(JsonReader in) throws IOException { + String collection = null; + String id = null; + + in.beginObject(); + in.nextName(); // expect "beacon"? + var beacon = in.nextString(); + + // Skip to the end of the object. There's going to be the "href" + // key too, which is irrelevant for us. + while (in.peek() != JsonToken.END_OBJECT) { + in.skipValue(); + } + in.endObject(); + + beacon = beacon.replaceFirst("weaviate://localhost/", ""); + if (beacon.contains("/")) { + var parts = beacon.split("/"); + collection = parts[0]; + id = parts[1]; + } else { + id = beacon; + } + + return new ObjectReference(collection, id); + } + + }.nullSafe(); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java new file mode 100644 index 000000000..284688daa --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java @@ -0,0 +1,35 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.ArrayList; +import java.util.List; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ReferenceAddManyRequest(List references) { + + public static final Endpoint endpoint( + List references, + CollectionHandleDefaults defaults) { + return new SimpleEndpoint<>( + request -> "POST", + request -> "/batch/references", + request -> defaults.queryParameters(), + request -> JSON.serialize(request.references), + (statusCode, response) -> { + var result = JSON.deserialize(response, ReferenceAddManyResponse.class); + var errors = new ArrayList(); + + for (var err : result.errors()) { + errors.add(new ReferenceAddManyResponse.BatchError( + err.message(), + references.get(err.referenceIndex()), + err.referenceIndex())); + } + return new ReferenceAddManyResponse(errors); + }); + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyResponse.java new file mode 100644 index 000000000..d7c70d7fa --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyResponse.java @@ -0,0 +1,47 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.List; + +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonDeserializer; +import com.google.gson.JsonElement; +import com.google.gson.JsonParseException; + +public record ReferenceAddManyResponse(List errors) { + public record BatchError(String message, BatchReference reference, int referenceIndex) { + } + + public static enum CustomJsonDeserializer implements JsonDeserializer { + INSTANCE; + + @Override + public ReferenceAddManyResponse deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) + throws JsonParseException { + + var errors = new ArrayList(); + int i = 0; + for (var el : json.getAsJsonArray()) { + var result = el.getAsJsonObject().get("result").getAsJsonObject(); + if (result.get("status").getAsString().equals("FAILED") + && result.has("errors")) { + String errorMsg; + try { + errorMsg = result + .get("errors").getAsJsonObject() + .get("error").getAsJsonArray() + .get(0).getAsString(); + } catch (Exception e) { + errorMsg = result.get("errors").toString(); + } + + var batchErr = new BatchError(errorMsg, null, i); + errors.add(batchErr); + } + i++; + } + return new ReferenceAddManyResponse(errors); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java new file mode 100644 index 000000000..174e868c2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.collections.data; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ReferenceAddRequest(String fromUuid, String fromProperty, ObjectReference reference) { + + public static final Endpoint endpoint( + CollectionDescriptor descriptor, + CollectionHandleDefaults defaults) { + return SimpleEndpoint.sideEffect( + request -> "POST", + request -> "/objects/" + descriptor.collectionName() + "/" + request.fromUuid + "/references/" + + request.fromProperty, + request -> defaults.queryParameters(), + request -> JSON.serialize(request.reference)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java new file mode 100644 index 000000000..d17336bb7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.collections.data; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ReferenceDeleteRequest(String fromUuid, String fromProperty, ObjectReference reference) { + + public static final Endpoint endpoint( + CollectionDescriptor descriptor, + CollectionHandleDefaults defaults) { + return SimpleEndpoint.sideEffect( + request -> "DELETE", + request -> "/objects/" + descriptor.collectionName() + "/" + request.fromUuid + "/references/" + + request.fromProperty, + request -> defaults.queryParameters(), + request -> JSON.serialize(request.reference)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java new file mode 100644 index 000000000..f68876ee7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java @@ -0,0 +1,23 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.List; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ReferenceReplaceRequest(String fromUuid, String fromProperty, ObjectReference reference) { + + public static final Endpoint endpoint( + CollectionDescriptor descriptor, + CollectionHandleDefaults defaults) { + return SimpleEndpoint.sideEffect( + request -> "PUT", + request -> "/objects/" + descriptor.collectionName() + "/" + request.fromUuid + "/references/" + + request.fromProperty, + request -> defaults.queryParameters(), + request -> JSON.serialize(List.of(request.reference))); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java new file mode 100644 index 000000000..13a1afacb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java @@ -0,0 +1,83 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.Collections; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ReplaceObjectRequest(WeaviateObject object) { + + static final Endpoint, Void> endpoint( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + + final var typeToken = TypeToken.getParameterized(WeaviateObject.class, collection.typeToken().getType()); + + return SimpleEndpoint.sideEffect( + request -> "PUT", + request -> "/objects/" + collection.collectionName() + "/" + request.object.uuid(), + request -> defaults.consistencyLevel() != null + ? Map.of("consistency_level", defaults.consistencyLevel()) + : Collections.emptyMap(), + request -> JSON.serialize( + new WeaviateObject<>( + request.object.uuid(), + collection.collectionName(), + defaults.tenant(), + request.object.properties(), + request.object.vectors(), + request.object.createdAt(), + request.object.lastUpdatedAt(), + null, + request.object.references()), + typeToken)); + } + + public static ReplaceObjectRequest of( + String uuid, + Function, ObjectBuilder>> fn) { + return fn.apply(new Builder<>(uuid)).build(); + } + + public ReplaceObjectRequest(Builder builder) { + this(builder.object.build()); + } + + public static class Builder implements ObjectBuilder> { + private final WeaviateObject.Builder object = new WeaviateObject.Builder<>(); + + public Builder(String uuid) { + this.object.uuid(uuid); + } + + public Builder properties(PropertiesT properties) { + this.object.properties(properties); + return this; + } + + public Builder vectors(Vectors... vectors) { + this.object.vectors(vectors); + return this; + } + + public Builder reference(String property, ObjectReference... references) { + this.object.reference(property, references); + return this; + } + + @Override + public ReplaceObjectRequest build() { + return new ReplaceObjectRequest<>(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java new file mode 100644 index 000000000..6157a1cc8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java @@ -0,0 +1,82 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.Collections; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record UpdateObjectRequest(WeaviateObject object) { + + static final Endpoint, Void> endpoint( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + + final var typeToken = TypeToken.getParameterized(WeaviateObject.class, collection.typeToken().getType()); + + return SimpleEndpoint.sideEffect( + request -> "PATCH", + request -> "/objects/" + collection.collectionName() + "/" + request.object.uuid(), + request -> defaults.consistencyLevel() != null + ? Map.of("consistency_level", defaults.consistencyLevel()) + : Collections.emptyMap(), + request -> JSON.serialize( + new WeaviateObject<>( + request.object.uuid(), + collection.collectionName(), + defaults.tenant(), + request.object.properties(), + request.object.vectors(), + request.object.createdAt(), + request.object.lastUpdatedAt(), + null, + request.object.references()), + typeToken)); + } + + public static UpdateObjectRequest of(String uuid, + Function, ObjectBuilder>> fn) { + return fn.apply(new Builder<>(uuid)).build(); + } + + public UpdateObjectRequest(Builder builder) { + this(builder.object.build()); + } + + public static class Builder implements ObjectBuilder> { + private final WeaviateObject.Builder object = new WeaviateObject.Builder<>(); + + public Builder(String uuid) { + this.object.uuid(uuid); + } + + public Builder properties(PropertiesT properties) { + this.object.properties(properties); + return this; + } + + public Builder vectors(Vectors... vectors) { + this.object.vectors(vectors); + return this; + } + + public Builder reference(String property, ObjectReference... references) { + this.object.reference(property, references); + return this; + } + + @Override + public UpdateObjectRequest build() { + return new UpdateObjectRequest<>(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java new file mode 100644 index 000000000..c7497ec64 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java @@ -0,0 +1,158 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.api.collections.query.FilterOperand; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateDataClient { + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + private final CollectionDescriptor collection; + + private final WeaviateQueryClient query; + private final CollectionHandleDefaults defaults; + + public WeaviateDataClient( + CollectionDescriptor collection, + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + this.collection = collection; + this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults); + this.defaults = defaults; + } + + /** Copy constructor that updates the {@link #query} to use new defaults. */ + public WeaviateDataClient(WeaviateDataClient c, CollectionHandleDefaults defaults) { + this.restTransport = c.restTransport; + this.grpcTransport = c.grpcTransport; + this.collection = c.collection; + this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults); + this.defaults = defaults; + } + + public WeaviateObject insert(PropertiesT properties) throws IOException { + return insert(InsertObjectRequest.of(properties)); + } + + public WeaviateObject insert( + PropertiesT properties, + Function, ObjectBuilder>> fn) + throws IOException { + return insert(InsertObjectRequest.of(properties, fn)); + } + + public WeaviateObject insert(InsertObjectRequest request) + throws IOException { + return this.restTransport.performRequest(request, InsertObjectRequest.endpoint(collection, defaults)); + } + + @SafeVarargs + public final InsertManyResponse insertMany(PropertiesT... objects) { + return insertMany(InsertManyRequest.of(objects)); + } + + public InsertManyResponse insertMany(List> objects) { + return insertMany(new InsertManyRequest<>(objects)); + } + + @SafeVarargs + public final InsertManyResponse insertMany(WeaviateObject... objects) { + return insertMany(Arrays.asList(objects)); + } + + public InsertManyResponse insertMany(InsertManyRequest request) { + return this.grpcTransport.performRequest(request, + InsertManyRequest.rpc(request.objects(), collection, defaults)); + } + + public boolean exists(String uuid) { + return this.query.fetchObjectById(uuid).isPresent(); + } + + public void update( + String uuid, + Function, ObjectBuilder>> fn) + throws IOException { + this.restTransport.performRequest(UpdateObjectRequest.of(uuid, fn), + UpdateObjectRequest.endpoint(collection, defaults)); + } + + public void replace( + String uuid, + Function, ObjectBuilder>> fn) + throws IOException { + this.restTransport.performRequest(ReplaceObjectRequest.of(uuid, fn), + ReplaceObjectRequest.endpoint(collection, defaults)); + } + + /** + * Delete an object by its UUID. + * + * @param uuid The UUID of the object to delete. + * @return {@code true} if the object was deleted, {@code false} if there was no + * object to delete. + * @throws IOException in case the request was not sent successfully. + */ + public boolean deleteById(String uuid) throws IOException { + return this.restTransport.performRequest(new DeleteObjectRequest(uuid), + DeleteObjectRequest.endpoint(collection, defaults)); + } + + public DeleteManyResponse deleteMany(String... uuids) { + var either = Arrays.stream(uuids) + .map(uuid -> (FilterOperand) Filter.uuid().eq(uuid)) + .toList(); + return deleteMany(DeleteManyRequest.of(Filter.or(either))); + } + + public DeleteManyResponse deleteMany(Filter filters) { + return deleteMany(DeleteManyRequest.of(filters)); + } + + public DeleteManyResponse deleteMany(Filter filters, + Function> fn) { + return deleteMany(DeleteManyRequest.of(filters, fn)); + } + + public DeleteManyResponse deleteMany(DeleteManyRequest request) { + return this.grpcTransport.performRequest(request, DeleteManyRequest.rpc(collection, defaults)); + } + + public void referenceAdd(String fromUuid, String fromProperty, ObjectReference reference) throws IOException { + this.restTransport.performRequest(new ReferenceAddRequest(fromUuid, fromProperty, reference), + ReferenceAddRequest.endpoint(collection, defaults)); + } + + public ReferenceAddManyResponse referenceAddMany(BatchReference... references) throws IOException { + return referenceAddMany(Arrays.asList(references)); + } + + public ReferenceAddManyResponse referenceAddMany(List references) throws IOException { + return this.restTransport.performRequest(new ReferenceAddManyRequest(references), + ReferenceAddManyRequest.endpoint(references, defaults)); + } + + public void referenceDelete(String fromUuid, String fromProperty, ObjectReference reference) throws IOException { + this.restTransport.performRequest(new ReferenceDeleteRequest(fromUuid, fromProperty, reference), + ReferenceDeleteRequest.endpoint(collection, defaults)); + } + + public void referenceReplace(String fromUuid, String fromProperty, ObjectReference reference) throws IOException { + this.restTransport.performRequest(new ReferenceReplaceRequest(fromUuid, fromProperty, reference), + ReferenceReplaceRequest.endpoint(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java new file mode 100644 index 000000000..cdbb2b08b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java @@ -0,0 +1,148 @@ +package io.weaviate.client6.v1.api.collections.data; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.api.collections.query.FilterOperand; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateDataClientAsync { + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + private final CollectionDescriptor collection; + + private final WeaviateQueryClientAsync query; + private final CollectionHandleDefaults defaults; + + public WeaviateDataClientAsync( + CollectionDescriptor collectionDescriptor, + RestTransport restTransport, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + this.collection = collectionDescriptor; + this.query = new WeaviateQueryClientAsync<>(collectionDescriptor, grpcTransport, defaults); + this.defaults = defaults; + } + + /** Copy constructor that updates the {@link #query} to use new defaults. */ + public WeaviateDataClientAsync(WeaviateDataClientAsync c, CollectionHandleDefaults defaults) { + this.restTransport = c.restTransport; + this.grpcTransport = c.grpcTransport; + this.collection = c.collection; + this.query = new WeaviateQueryClientAsync<>(collection, grpcTransport, defaults); + this.defaults = defaults; + } + + public CompletableFuture> insert(PropertiesT properties) { + return insert(InsertObjectRequest.of(properties)); + } + + public CompletableFuture> insert( + PropertiesT properties, + Function, ObjectBuilder>> fn) { + return insert(InsertObjectRequest.of(properties, fn)); + } + + public CompletableFuture> insert( + InsertObjectRequest request) { + return this.restTransport.performRequestAsync(request, InsertObjectRequest.endpoint(collection, defaults)); + } + + @SafeVarargs + public final CompletableFuture insertMany(PropertiesT... objects) { + return insertMany(InsertManyRequest.of(objects)); + } + + @SafeVarargs + public final CompletableFuture insertMany(WeaviateObject... objects) { + return insertMany(Arrays.asList(objects)); + } + + public CompletableFuture insertMany(List> objects) { + return insertMany(new InsertManyRequest<>(objects)); + } + + public CompletableFuture insertMany(InsertManyRequest request) { + return this.grpcTransport.performRequestAsync(request, + InsertManyRequest.rpc(request.objects(), collection, defaults)); + } + + public CompletableFuture exists(String uuid) { + return this.query.fetchObjectById(uuid).thenApply(Optional::isPresent); + } + + public CompletableFuture update( + String uuid, + Function, ObjectBuilder>> fn) { + return this.restTransport.performRequestAsync(UpdateObjectRequest.of(uuid, fn), + UpdateObjectRequest.endpoint(collection, defaults)); + } + + public CompletableFuture replace( + String uuid, + Function, ObjectBuilder>> fn) { + return this.restTransport.performRequestAsync(ReplaceObjectRequest.of(uuid, fn), + ReplaceObjectRequest.endpoint(collection, defaults)); + } + + public CompletableFuture delete(String uuid) { + return this.restTransport.performRequestAsync(new DeleteObjectRequest(uuid), + DeleteObjectRequest.endpoint(collection, defaults)); + } + + public CompletableFuture deleteMany(String... uuids) { + var either = Arrays.stream(uuids) + .map(uuid -> (FilterOperand) Filter.uuid().eq(uuid)) + .toList(); + return deleteMany(DeleteManyRequest.of(Filter.or(either))); + } + + public CompletableFuture deleteMany(Filter filters) { + return deleteMany(DeleteManyRequest.of(filters)); + } + + public CompletableFuture deleteMany(Filter filters, + Function> fn) { + return deleteMany(DeleteManyRequest.of(filters, fn)); + } + + public CompletableFuture deleteMany(DeleteManyRequest request) { + return this.grpcTransport.performRequestAsync(request, DeleteManyRequest.rpc(collection, defaults)); + } + + public CompletableFuture referenceAdd(String fromUuid, String fromProperty, ObjectReference reference) { + return this.restTransport.performRequestAsync(new ReferenceAddRequest(fromUuid, fromProperty, reference), + ReferenceAddRequest.endpoint(collection, defaults)); + } + + public CompletableFuture referenceAddMany(BatchReference... references) { + return referenceAddMany(Arrays.asList(references)); + } + + public CompletableFuture referenceAddMany(List references) { + return this.restTransport.performRequestAsync(new ReferenceAddManyRequest(references), + ReferenceAddManyRequest.endpoint(references, defaults)); + } + + public CompletableFuture referenceDelete(String fromUuid, String fromProperty, ObjectReference reference) { + return this.restTransport.performRequestAsync(new ReferenceDeleteRequest(fromUuid, fromProperty, reference), + ReferenceDeleteRequest.endpoint(collection, defaults)); + } + + public CompletableFuture referenceReplace(String fromUuid, String fromProperty, ObjectReference reference) { + return this.restTransport.performRequestAsync(new ReferenceReplaceRequest(fromUuid, fromProperty, reference), + ReferenceReplaceRequest.endpoint(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/encoding/MuveraEncoding.java b/src/main/java/io/weaviate/client6/v1/api/collections/encoding/MuveraEncoding.java new file mode 100644 index 000000000..9db2a9be8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/encoding/MuveraEncoding.java @@ -0,0 +1,73 @@ +package io.weaviate.client6.v1.api.collections.encoding; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Encoding; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record MuveraEncoding( + @SerializedName("enabled") boolean enabled, + @SerializedName("ksim") Integer ksim, + @SerializedName("dprojections") Integer dprojections, + @SerializedName("repetitions") Integer repetitions) implements Encoding { + + public static MuveraEncoding of() { + return of(ObjectBuilder.identity()); + } + + public static MuveraEncoding of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public MuveraEncoding(Builder builder) { + this( + builder.enabled, + builder.ksim, + builder.dprojections, + builder.repetitions); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer ksim; + private Integer dprojections; + private Integer repetitions; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder ksim(int ksim) { + this.ksim = ksim; + return this; + } + + public Builder dprojections(int dprojections) { + this.dprojections = dprojections; + return this; + } + + public Builder repetitions(int repetitions) { + this.repetitions = repetitions; + return this; + } + + @Override + public MuveraEncoding build() { + return new MuveraEncoding(this); + } + } + + @Override + public Encoding.Kind _kind() { + return Encoding.Kind.MUVERA; + } + + @Override + public Object _self() { + return this; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/AbstractGenerateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/AbstractGenerateClient.java new file mode 100644 index 000000000..cb80eb75c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/AbstractGenerateClient.java @@ -0,0 +1,1898 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.Bm25; +import io.weaviate.client6.v1.api.collections.query.FetchObjects; +import io.weaviate.client6.v1.api.collections.query.GroupBy; +import io.weaviate.client6.v1.api.collections.query.Hybrid; +import io.weaviate.client6.v1.api.collections.query.NearAudio; +import io.weaviate.client6.v1.api.collections.query.NearDepth; +import io.weaviate.client6.v1.api.collections.query.NearImage; +import io.weaviate.client6.v1.api.collections.query.NearImu; +import io.weaviate.client6.v1.api.collections.query.NearObject; +import io.weaviate.client6.v1.api.collections.query.NearText; +import io.weaviate.client6.v1.api.collections.query.NearThermal; +import io.weaviate.client6.v1.api.collections.query.NearVector; +import io.weaviate.client6.v1.api.collections.query.NearVectorTarget; +import io.weaviate.client6.v1.api.collections.query.NearVideo; +import io.weaviate.client6.v1.api.collections.query.QueryOperator; +import io.weaviate.client6.v1.api.collections.query.Target; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +abstract class AbstractGenerateClient { + protected final CollectionDescriptor collection; + protected final GrpcTransport grpcTransport; + protected final CollectionHandleDefaults defaults; + + AbstractGenerateClient(CollectionDescriptor collection, GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.collection = collection; + this.grpcTransport = grpcTransport; + this.defaults = defaults; + } + + /** Copy constructor that sets new defaults. */ + AbstractGenerateClient( + AbstractGenerateClient c, + CollectionHandleDefaults defaults) { + this(c.collection, c.grpcTransport, defaults); + } + + protected abstract ResponseT performRequest(QueryOperator operator, GenerativeTask generate); + + protected abstract GroupedResponseT performRequest(QueryOperator operator, GenerativeTask generate, GroupBy groupBy); + + // Object queries ----------------------------------------------------------- + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter + * and run a generative task on the query results. + * + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT fetchObjects(Function> fn, + Function> generateFn) { + return fetchObjects(FetchObjects.of(fn), GenerativeTask.of(generateFn)); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter + * and run a generative task on the query results. + * + * @param query FetchObjects query. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT fetchObjects(FetchObjects query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter + * and run a generative task on the query results. + * + * + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT fetchObjects(Function> fn, + Function> generateFn, + GroupBy groupBy) { + return fetchObjects(FetchObjects.of(fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter + * and run a generative task on the query results. + * + * @param query FetchObjects query. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT fetchObjects(FetchObjects query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // BM25 queries ------------------------------------------------------------- + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query Query string. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25(String query, + Function> generateFn) { + return bm25(Bm25.of(query), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query Query string. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25( + String query, + Function> fn, + Function> generateFn) { + return bm25(Bm25.of(query, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query BM25 query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25(Bm25 query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query Query string. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT bm25(String query, + Function> generateFn, + GroupBy groupBy) { + return bm25(Bm25.of(query), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query Query string. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT bm25(String query, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return bm25(Bm25.of(query, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a keyword (BM25) search. + * + * @param query BM25 query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT bm25(Bm25 query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // Hybrid queries ----------------------------------------------------------- + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Query string. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(String query, + Function> generateFn) { + return hybrid(Hybrid.of(query), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Query string. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid( + String query, + Function> fn, + Function> generateFn) { + return hybrid(Hybrid.of(query, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param searchTarget Query target. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid( + Target searchTarget, + Function> generateFn) { + return hybrid(Hybrid.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid( + Target searchTarget, + Function> fn, + Function> generateFn) { + return hybrid(Hybrid.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Hybrid query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(Hybrid query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Query string. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT hybrid( + String query, + Function> generateFn, + GroupBy groupBy) { + return hybrid(Hybrid.of(query), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Query string. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT hybrid( + String query, + Function> generateFn, + Function> fn, GroupBy groupBy) { + return hybrid(Hybrid.of(query, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param searchTarget Query target. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT hybrid( + Target searchTarget, + Function> generateFn, + GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT hybrid( + Target searchTarget, + Function> generateFn, + Function> fn, + GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a hybrid search. + * + * @param query Query string. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT hybrid(Hybrid query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearVector queries ------------------------------------------------------- + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[] vector, + Function> generateFn) { + return nearVector(Target.vector(vector), generateFn); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[] vector, + Function> fn, + Function> generateFn) { + return nearVector(Target.vector(vector), fn, generateFn); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[][] vector, + Function> generateFn) { + return nearVector(Target.vector(vector), generateFn); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[][] vector, + Function> fn, + Function> generateFn) { + return nearVector(Target.vector(vector), fn, generateFn); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param searchTarget Target query vectors. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVectorTarget searchTarget, + Function> generateFn) { + return nearVector(NearVector.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param searchTarget Target query vectors. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVectorTarget searchTarget, + Function> fn, + Function> generateFn) { + return nearVector(NearVector.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param query Near vector query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVector query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, + Function> generateFn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), fn, generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, + Function> generateFn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), fn, generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param searchTarget Target query vectors. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector( + NearVectorTarget searchTarget, + Function> generateFn, + GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param searchTarget Target query vectors. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(NearVectorTarget searchTarget, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near vector search. + * + * @param query Near vector query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVector(NearVector query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearObject queries ------------------------------------------------------- + + /** + * Run a generative task on the results of a near object search. + * + * @param uuid Query object UUID. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(String uuid, + Function> generateFn) { + return nearObject(NearObject.of(uuid), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near object search. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(String uuid, + Function> fn, + Function> generateFn) { + return nearObject(NearObject.of(uuid, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near object search. + * + * @param query Near object query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(NearObject query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near object search. + * + * @param uuid Query object UUID. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, + Function> generateFn, + GroupBy groupBy) { + return nearObject(NearObject.of(uuid), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near object search. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearObject(NearObject.of(uuid, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near object search. + * + * @param query Near object query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearObject(NearObject query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearText queries --------------------------------------------------------- + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(String text, + Function> fn, + Function> generateFn) { + return nearText(Target.text(List.of(text)), fn, generateFn); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(List text, + Function> fn, + Function> generateFn) { + return nearText(Target.text(text), fn, generateFn); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param searchTarget Target query concepts. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(Target searchTarget, + Function> generateFn) { + return nearText(NearText.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param searchTarget Target query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(Target searchTarget, + Function> fn, + Function> generateFn) { + return nearText(NearText.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param query Near text query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(NearText query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(String text, + Function> generateFn, + GroupBy groupBy) { + return nearText(Target.text(List.of(text)), generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(List text, + Function> generateFn, GroupBy groupBy) { + return nearText(Target.text(text), generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(String text, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearText(Target.text(List.of(text)), fn, generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(List text, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearText(Target.text(text), fn, generateFn, groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param searchTarget Target query concepts. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearText(NearText.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param searchTarget Target query concepts. + * @param fn Lambda expression for optional parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, + Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearText(NearText.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near text search. + * + * @param query Near text query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearText(NearText query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearImage queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near image search. + * + * @param image Query image (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(String image, + Function> generateFn) { + return nearImage(NearImage.of(image), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param image Query image (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(String image, Function> fn, + Function> generateFn) { + return nearImage(NearImage.of(image, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(Target searchTarget, + Function> generateFn) { + return nearImage(NearImage.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(Target searchTarget, Function> fn, + Function> generateFn) { + return nearImage(NearImage.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param query Near image query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(NearImage query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param image Query image (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImage(String image, + Function> generateFn, GroupBy groupBy) { + return nearImage(NearImage.of(image), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImage(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImage(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param image Query image (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImage(String image, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearImage(NearImage.of(image, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near image search. + * + * @param query Near image query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImage(NearImage query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearAudio queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near audio search. + * + * @param audio Query audio (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(String audio, + Function> generateFn) { + return nearAudio(NearAudio.of(audio), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param audio Query audio (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(String audio, Function> fn, + Function> generateFn) { + return nearAudio(NearAudio.of(audio, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(Target searchTarget, + Function> generateFn) { + return nearAudio(NearAudio.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(Target searchTarget, Function> fn, + Function> generateFn) { + return nearAudio(NearAudio.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param query Near audio query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(NearAudio query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param audio Query audio (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearAudio(String audio, + Function> generateFn, GroupBy groupBy) { + return nearAudio(NearAudio.of(audio), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearAudio(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearAudio(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param audio Query audio (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearAudio(String audio, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(audio, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near audio search. + * + * @param query Near audio query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearAudio(NearAudio query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearVideo queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near video search. + * + * @param video Query video (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(String video, + Function> generateFn) { + return nearVideo(NearVideo.of(video), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param video Query video (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(String video, Function> fn, + Function> generateFn) { + return nearVideo(NearVideo.of(video, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(Target searchTarget, + Function> generateFn) { + return nearVideo(NearVideo.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(Target searchTarget, Function> fn, + Function> generateFn) { + return nearVideo(NearVideo.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param query Near video query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(NearVideo query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param video Query video (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearVideo(String video, + Function> generateFn, GroupBy groupBy) { + return nearVideo(NearVideo.of(video), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVideo(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearVideo(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param video Query video (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVideo(String video, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(video, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near video search. + * + * @param query Near video query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearVideo(NearVideo query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearThermal queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(String thermal, + Function> generateFn) { + return nearThermal(NearThermal.of(thermal), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(String thermal, Function> fn, + Function> generateFn) { + return nearThermal(NearThermal.of(thermal, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(Target searchTarget, + Function> generateFn) { + return nearThermal(NearThermal.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(Target searchTarget, Function> fn, + Function> generateFn) { + return nearThermal(NearThermal.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param query Near thermal query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(NearThermal query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearThermal(String thermal, + Function> generateFn, GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearThermal(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearThermal(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearThermal(String thermal, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near thermal search. + * + * @param query Near thermal query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearThermal(NearThermal query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearDepth queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near depth search. + * + * @param depth Query depth (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(String depth, + Function> generateFn) { + return nearDepth(NearDepth.of(depth), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param depth Query depth (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(String depth, Function> fn, + Function> generateFn) { + return nearDepth(NearDepth.of(depth, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param searchTarget Query target (base64-encoded depth). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(Target searchTarget, + Function> generateFn) { + return nearDepth(NearDepth.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param searchTarget Query target (base64-encoded depth). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(Target searchTarget, Function> fn, + Function> generateFn) { + return nearDepth(NearDepth.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param query Near depth query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(NearDepth query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param depth Query depth (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearDepth(String depth, + Function> generateFn, GroupBy groupBy) { + return nearDepth(NearDepth.of(depth), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param searchTarget Query target (base64-encoded depth). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearDepth(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param searchTarget Query target (base64-encoded depth). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearDepth(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param depth Query depth (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearDepth(String depth, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(depth, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near depth search. + * + * @param query Near depth query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearDepth(NearDepth query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } + + // NearImu queries -------------------------------------------------------- + + /** + * Run a generative task on the results of a near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(String imu, + Function> generateFn) { + return nearImu(NearImu.of(imu), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(String imu, Function> fn, + Function> generateFn) { + return nearImu(NearImu.of(imu, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU). + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(Target searchTarget, + Function> generateFn) { + return nearImu(NearImu.of(searchTarget), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(Target searchTarget, Function> fn, + Function> generateFn) { + return nearImu(NearImu.of(searchTarget, fn), GenerativeTask.of(generateFn)); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param query Near IMU query request. + * @param generate Generative task. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(NearImu query, GenerativeTask generate) { + return performRequest(query, generate); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImu(String imu, + Function> generateFn, GroupBy groupBy) { + return nearImu(NearImu.of(imu), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImu(Target searchTarget, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU). + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see GenerativeResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImu(Target searchTarget, + Function> generateFn, GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param fn Lambda expression for optional search parameters. + * @param generateFn Lambda expression for generative task parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImu(String imu, Function> fn, + Function> generateFn, + GroupBy groupBy) { + return nearImu(NearImu.of(imu, fn), GenerativeTask.of(generateFn), groupBy); + } + + /** + * Run a generative task on the results of a near IMU search. + * + * @param query Near IMU query request. + * @param generate Generative task. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see GenerativeResponseGrouped + */ + public GroupedResponseT nearImu(NearImu query, GenerativeTask generate, GroupBy groupBy) { + return performRequest(query, generate, groupBy); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeDebug.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeDebug.java new file mode 100644 index 000000000..4b08cdc12 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeDebug.java @@ -0,0 +1,4 @@ +package io.weaviate.client6.v1.api.collections.generate; + +public record GenerativeDebug(String fullPrompt) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeObject.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeObject.java new file mode 100644 index 000000000..b0e95dcc1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeObject.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.query.QueryMetadata; + +public record GenerativeObject( + /** Object UUID. */ + String uuid, + /** Retrieved object vectors. */ + Vectors vectors, + /** Object properties. */ + PropertiesT properties, + /** Object metadata. */ + QueryMetadata metadata, + /** Generative task output. */ + TaskOutput generative) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeProvider.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeProvider.java new file mode 100644 index 000000000..61085180f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeProvider.java @@ -0,0 +1,184 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.generative.AnthropicGenerative; +import io.weaviate.client6.v1.api.collections.generative.AnyscaleGenerative; +import io.weaviate.client6.v1.api.collections.generative.AwsGenerative; +import io.weaviate.client6.v1.api.collections.generative.AzureOpenAiGenerative; +import io.weaviate.client6.v1.api.collections.generative.CohereGenerative; +import io.weaviate.client6.v1.api.collections.generative.DatabricksGenerative; +import io.weaviate.client6.v1.api.collections.generative.FriendliaiGenerative; +import io.weaviate.client6.v1.api.collections.generative.GoogleGenerative; +import io.weaviate.client6.v1.api.collections.generative.MistralGenerative; +import io.weaviate.client6.v1.api.collections.generative.NvidiaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OllamaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OpenAiGenerative; +import io.weaviate.client6.v1.api.collections.generative.XaiGenerative; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public interface GenerativeProvider { + void appendTo(WeaviateProtoGenerative.GenerativeProvider.Builder req); + + /** + * Configure {@code generative-anthropic} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider anthropic( + Function> fn) { + return AnthropicGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-anyscale} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider anyscale( + Function> fn) { + return AnyscaleGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-aws} as a dynamic provider. + * + * @param region AWS region. + * @param model Inference model. + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider awsBedrock( + String region, + String model, + Function> fn) { + return AwsGenerative.Provider.bedrock(region, model, fn); + } + + /** + * Configure {@code generative-aws} as a dynamic provider. + * + * @param region AWS region. + * @param endpoint Base inference URL. + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider awsSagemaker( + String region, + String endpoint, + Function> fn) { + return AwsGenerative.Provider.sagemaker(region, endpoint, fn); + } + + /** + * Configure {@code generative-cohere} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider cohere( + Function> fn) { + return CohereGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-databricks} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider databricks( + Function> fn) { + return DatabricksGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-friendliai} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider friendliai( + Function> fn) { + return FriendliaiGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-google} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider googleAiStudio( + Function> fn) { + return GoogleGenerative.Provider.aiStudio(fn); + } + + /** + * Configure {@code generative-google} as a dynamic provider. + * + * @param projectId Google project ID. + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider googleVertex( + String projectId, + Function> fn) { + return GoogleGenerative.Provider.vertex(projectId, fn); + } + + /** + * Configure {@code generative-mistral} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider mistral( + Function> fn) { + return MistralGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-nvidia} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider nvidia( + Function> fn) { + return NvidiaGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-ollama} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider ollama( + Function> fn) { + return OllamaGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-openai} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider openai( + Function> fn) { + return OpenAiGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-openai} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider azure( + Function> fn) { + return AzureOpenAiGenerative.Provider.of(fn); + } + + /** + * Configure {@code generative-xai} as a dynamic provider. + * + * @param fn Lambda expression for optional parameters. + */ + public static GenerativeProvider xai( + Function> fn) { + return XaiGenerative.Provider.of(fn); + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeRequest.java new file mode 100644 index 000000000..b09ce9f4e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeRequest.java @@ -0,0 +1,43 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.GroupBy; +import io.weaviate.client6.v1.api.collections.query.QueryOperator; +import io.weaviate.client6.v1.api.collections.query.QueryRequest; +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record GenerativeRequest(QueryOperator operator, GenerativeTask generate, GroupBy groupBy) { + static Rpc, WeaviateProtoSearchGet.SearchReply> rpc( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return Rpc.of( + request -> { + var query = QueryRequest.marshal( + new QueryRequest(request.operator, request.groupBy), + collection, defaults); + var generative = WeaviateProtoGenerative.GenerativeSearch.newBuilder(); + request.generate.appendTo(generative); + var builder = query.toBuilder(); + builder.setGenerative(generative); + return builder.build(); + }, + reply -> GenerativeResponse.unmarshal(reply, collection), + () -> WeaviateBlockingStub::search, + () -> WeaviateFutureStub::search); + } + + static Rpc, WeaviateProtoSearchGet.SearchReply> grouped( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var rpc = rpc(collection, defaults); + return Rpc.of( + request -> rpc.marshal(request), + reply -> GenerativeResponseGrouped.unmarshal(reply, collection, defaults), + () -> rpc.method(), () -> rpc.methodAsync()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponse.java new file mode 100644 index 000000000..e4db43a9d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponse.java @@ -0,0 +1,176 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.ArrayList; +import java.util.List; + +import io.weaviate.client6.v1.api.collections.generative.AnthropicGenerative; +import io.weaviate.client6.v1.api.collections.generative.AnyscaleGenerative; +import io.weaviate.client6.v1.api.collections.generative.AwsGenerative; +import io.weaviate.client6.v1.api.collections.generative.CohereGenerative; +import io.weaviate.client6.v1.api.collections.generative.DatabricksGenerative; +import io.weaviate.client6.v1.api.collections.generative.DummyGenerative; +import io.weaviate.client6.v1.api.collections.generative.FriendliaiGenerative; +import io.weaviate.client6.v1.api.collections.generative.GoogleGenerative; +import io.weaviate.client6.v1.api.collections.generative.MistralGenerative; +import io.weaviate.client6.v1.api.collections.generative.NvidiaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OllamaGenerative; +import io.weaviate.client6.v1.api.collections.generative.OpenAiGenerative; +import io.weaviate.client6.v1.api.collections.generative.ProviderMetadata; +import io.weaviate.client6.v1.api.collections.generative.XaiGenerative; +import io.weaviate.client6.v1.api.collections.query.QueryResponse; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record GenerativeResponse( + float took, + List> objects, + TaskOutput generative) { + static GenerativeResponse unmarshal( + WeaviateProtoSearchGet.SearchReply reply, + CollectionDescriptor collection) { + var objects = reply + .getResultsList() + .stream() + .map(result -> { + var object = QueryResponse.unmarshalResultObject( + result.getProperties(), result.getMetadata(), collection); + TaskOutput generative = null; + if (result.hasGenerative()) { + generative = GenerativeResponse.unmarshalTaskOutput(result.getGenerative()); + } + return new GenerativeObject<>( + object.uuid(), + object.vectors(), + object.properties(), + object.queryMetadata(), + generative); + }) + .toList(); + + TaskOutput summary = null; + if (reply.hasGenerativeGroupedResults()) { + summary = GenerativeResponse.unmarshalTaskOutput(reply.getGenerativeGroupedResults()); + } + return new GenerativeResponse<>(reply.getTook(), objects, summary); + } + + static TaskOutput unmarshalTaskOutput(List values) { + if (values.isEmpty()) { + return null; + } + var generative = values.get(0); + + var metadata = generative.getMetadata(); + ProviderMetadata providerMetadata = null; + if (metadata.hasDummy()) { + providerMetadata = new DummyGenerative.Metadata(); + } else if (metadata.hasAws()) { + providerMetadata = new AwsGenerative.Metadata(); + } else if (metadata.hasAnthropic()) { + var anthropic = metadata.getAnthropic(); + var usage = anthropic.getUsage(); + providerMetadata = new AnthropicGenerative.Metadata(new AnthropicGenerative.Metadata.Usage( + usage.getInputTokens(), + usage.getOutputTokens())); + } else if (metadata.hasAnyscale()) { + providerMetadata = new AnyscaleGenerative.Metadata(); + } else if (metadata.hasCohere()) { + var cohere = metadata.getCohere(); + var apiVersion = cohere.getApiVersion(); + var billedUnits = cohere.getBilledUnits(); + var tokens = cohere.getTokens(); + providerMetadata = new CohereGenerative.Metadata( + new CohereGenerative.Metadata.ApiVersion( + apiVersion.hasVersion() ? apiVersion.getVersion() : null, + apiVersion.hasIsDeprecated() ? apiVersion.getIsDeprecated() : null, + apiVersion.hasIsExperimental() ? apiVersion.getIsExperimental() : null), + new CohereGenerative.Metadata.BilledUnits(billedUnits.getInputTokens(), + billedUnits.hasOutputTokens() ? billedUnits.getOutputTokens() : null, + billedUnits.hasSearchUnits() ? billedUnits.getSearchUnits() : null, + billedUnits.hasClassifications() ? billedUnits.getClassifications() : null), + new CohereGenerative.Metadata.Tokens( + tokens.hasInputTokens() ? tokens.getInputTokens() : null, + tokens.hasOutputTokens() ? tokens.getOutputTokens() : null), + new ArrayList<>(cohere.getWarnings().getValuesList())); + } else if (metadata.hasDatabricks()) { + var databricks = metadata.getDatabricks(); + var usage = databricks.getUsage(); + providerMetadata = new DatabricksGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } else if (metadata.hasFriendliai()) { + var friendliai = metadata.getFriendliai(); + var usage = friendliai.getUsage(); + providerMetadata = new FriendliaiGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } else if (metadata.hasMistral()) { + var mistral = metadata.getMistral(); + var usage = mistral.getUsage(); + providerMetadata = new MistralGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } else if (metadata.hasNvidia()) { + var nvidia = metadata.getNvidia(); + var usage = nvidia.getUsage(); + providerMetadata = new NvidiaGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } else if (metadata.hasOllama()) { + providerMetadata = new OllamaGenerative.Metadata(); + } else if (metadata.hasOpenai()) { + var openai = metadata.getOpenai(); + var usage = openai.getUsage(); + providerMetadata = new OpenAiGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } else if (metadata.hasGoogle()) { + var google = metadata.getGoogle(); + var tokens = google.getMetadata().getTokenMetadata(); + var usage = google.getUsageMetadata(); + providerMetadata = new GoogleGenerative.Metadata( + new GoogleGenerative.Metadata.TokenMetadata( + new GoogleGenerative.Metadata.TokenCount( + tokens.getInputTokenCount().hasTotalBillableCharacters() + ? tokens.getInputTokenCount().getTotalBillableCharacters() + : null, + tokens.getInputTokenCount().hasTotalTokens() + ? tokens.getInputTokenCount().getTotalTokens() + : null), + new GoogleGenerative.Metadata.TokenCount( + tokens.getOutputTokenCount().hasTotalBillableCharacters() + ? tokens.getOutputTokenCount().getTotalBillableCharacters() + : null, + tokens.getOutputTokenCount().hasTotalTokens() + ? tokens.getOutputTokenCount().getTotalTokens() + : null)), + new GoogleGenerative.Metadata.Usage( + usage.hasPromptTokenCount() ? usage.getPromptTokenCount() : null, + usage.hasCandidatesTokenCount() ? usage.getCandidatesTokenCount() : null, + usage.hasTotalTokenCount() ? usage.getTotalTokenCount() : null)); + } else if (metadata.hasXai()) { + var xai = metadata.getXai(); + var usage = xai.getUsage(); + providerMetadata = new XaiGenerative.Metadata(new ProviderMetadata.Usage( + usage.hasPromptTokens() ? usage.getPromptTokens() : null, + usage.hasCompletionTokens() ? usage.getCompletionTokens() : null, + usage.hasTotalTokens() ? usage.getTotalTokens() : null)); + } + + GenerativeDebug debug = null; + if (generative.getDebug() != null && generative.getDebug().getFullPrompt() != null) { + debug = new GenerativeDebug(generative.getDebug().getFullPrompt()); + } + return new TaskOutput(generative.getResult(), providerMetadata, debug); + } + + static TaskOutput unmarshalTaskOutput(WeaviateProtoGenerative.GenerativeResult result) { + return unmarshalTaskOutput(result.getValuesList()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGroup.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGroup.java new file mode 100644 index 000000000..8ab444d11 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGroup.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.List; + +import io.weaviate.client6.v1.api.collections.query.QueryObjectGrouped; + +public record GenerativeResponseGroup( + /** Group name. */ + String name, + /** + * The smallest distance value among all objects in the group, indicating the + * most similar object in that group to the query + */ + Float minDistance, + /** + * The largest distance value among all objects in the group, indicating the + * least similar object in that group to the query. + */ + Float maxDistance, + /** The size of the group. */ + long numberOfObjects, + /** Objects retrieved in the query. */ + List> objects, + /** Output of the summary task for this group. */ + TaskOutput generative) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGrouped.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGrouped.java new file mode 100644 index 000000000..95710580c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeResponseGrouped.java @@ -0,0 +1,79 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.QueryObjectGrouped; +import io.weaviate.client6.v1.api.collections.query.QueryResponse; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record GenerativeResponseGrouped( + /** Execution time of the request as measure by the server. */ + float took, + /** Objects returned by the associated query. */ + List> objects, + /** Grouped results with per-group generated output. */ + Map> groups, + /** Output of the summary group task. */ + TaskOutput generative) { + + static GenerativeResponseGrouped unmarshal( + WeaviateProtoSearchGet.SearchReply reply, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var allObjects = new ArrayList>(); + var groups = reply.getGroupByResultsList().stream() + .map(group -> { + var groupName = group.getName(); + List> objects = group.getObjectsList().stream() + .map(object -> QueryResponse.unmarshalResultObject( + object.getProperties(), + object.getMetadata(), + collection)) + .map(object -> new QueryObjectGrouped<>( + object.uuid(), + object.vectors(), + object.properties(), + object.queryMetadata(), + groupName)) + .toList(); + + allObjects.addAll(objects); + + TaskOutput generative = null; + if (group.hasGenerativeResult()) { + generative = GenerativeResponse.unmarshalTaskOutput(group.getGenerativeResult()); + } else if (group.hasGenerative()) { + // As of today the server continues to use the deprecated field in response. + generative = GenerativeResponse.unmarshalTaskOutput(List.of(group.getGenerative())); + } + + return new GenerativeResponseGroup<>( + groupName, + group.getMinDistance(), + group.getMaxDistance(), + group.getNumberOfObjects(), + objects, + generative); + }) + // Collectors.toMap() throws an NPE if either key or value in the map are null. + // In this specific case it is safe to use it, as the function in the map above + // always returns a QueryResponseGroup. + // The name of the group should not be null either, that's something we assume + // about the server's response. + .collect(Collectors.toMap(GenerativeResponseGroup::name, Function.identity())); + + TaskOutput summary = null; + if (reply.hasGenerativeGroupedResults()) { + summary = GenerativeResponse.unmarshalTaskOutput(reply.getGenerativeGroupedResults()); + } else if (reply.hasGenerativeGroupedResult()) { + summary = new TaskOutput(reply.getGenerativeGroupedResult(), null, null); + } + return new GenerativeResponseGrouped<>(reply.getTook(), allObjects, groups, summary); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeTask.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeTask.java new file mode 100644 index 000000000..aff3548d3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/GenerativeTask.java @@ -0,0 +1,223 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record GenerativeTask(Single single, Grouped grouped) { + public static GenerativeTask of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public GenerativeTask(Builder builder) { + this(builder.single, builder.grouped); + } + + public static class Builder implements ObjectBuilder { + private Single single; + private Grouped grouped; + + public Builder singlePrompt(String prompt) { + this.single = Single.of(prompt); + return this; + } + + public Builder singlePrompt(String prompt, Function> fn) { + this.single = Single.of(prompt, fn); + return this; + + } + + public Builder groupedTask(String prompt) { + this.grouped = Grouped.of(prompt); + return this; + } + + public Builder groupedTask(String prompt, Function> fn) { + this.grouped = Grouped.of(prompt, fn); + return this; + } + + @Override + public GenerativeTask build() { + return new GenerativeTask(this); + } + } + + void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + if (single != null) { + single.appendTo(req); + } + if (grouped != null) { + grouped.appendTo(req); + } + } + + public record Single(String prompt, boolean debug, boolean returnMetadata, List providers) { + public static Single of(String prompt) { + return of(prompt, ObjectBuilder.identity()); + } + + public static Single of(String prompt, Function> fn) { + return fn.apply(new Builder(prompt)).build(); + } + + public Single(Builder builder) { + this(builder.prompt, + builder.debug, + builder.returnMetadata, + builder.providers); + } + + public static class Builder implements ObjectBuilder { + private final String prompt; + private final List providers = new ArrayList<>(); + private boolean debug = false; + private boolean returnMetadata = false; + + public Builder(String prompt) { + this.prompt = prompt; + } + + public Builder debug(boolean enable) { + this.debug = enable; + return this; + } + + /** + * Return generative provider metadata alongside the query result. Metadata is + * only available if {@link #generativeProvider(GenerativeProvider)} is set + * explicitly.. + */ + public Builder metadata(boolean enable) { + this.returnMetadata = enable; + return this; + } + + public Builder generativeProvider(GenerativeProvider provider) { + providers.clear(); // Protobuf allows `repeated` but the server expects there to be 1. + providers.add(provider); + return this; + } + + @Override + public Single build() { + return new Single(this); + } + } + + public void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + var ragProviders = providers.stream() + .map(provider -> { + var proto = WeaviateProtoGenerative.GenerativeProvider.newBuilder(); + provider.appendTo(proto); + proto.setReturnMetadata(returnMetadata); + return proto.build(); + }) + .toList(); + + req.setSingle( + WeaviateProtoGenerative.GenerativeSearch.Single.newBuilder() + .setPrompt(prompt) + .setDebug(debug) + .addAllQueries(ragProviders)); + } + } + + public record Grouped(String prompt, boolean debug, boolean returnMetadata, List properties, + List providers) { + public static Grouped of(String prompt) { + return of(prompt, ObjectBuilder.identity()); + } + + public static Grouped of(String prompt, Function> fn) { + return fn.apply(new Builder(prompt)).build(); + } + + public Grouped(Builder builder) { + this( + builder.prompt, + builder.debug, + builder.returnMetadata, + builder.properties, + builder.providers); + } + + public static class Builder implements ObjectBuilder { + private final String prompt; + private final List providers = new ArrayList<>(); + private final List properties = new ArrayList<>(); + private boolean debug = false; + private boolean returnMetadata = false; + + public Builder(String prompt) { + this.prompt = prompt; + } + + public Builder properties(String... properties) { + return properties(Arrays.asList(properties)); + } + + public Builder properties(List properties) { + this.properties.addAll(properties); + return this; + } + + public Builder generativeProvider(GenerativeProvider provider) { + providers.clear(); // Protobuf allows `repeated` but the server expects there to be 1. + providers.add(provider); + return this; + } + + /** + * Return generative provider metadata alongside the query result. Metadata is + * only available if {@link #generativeProvider(GenerativeProvider)} is set + * explicitly.. + */ + public Builder metadata(boolean enable) { + this.returnMetadata = enable; + return this; + } + + public Builder debug(boolean enable) { + this.debug = enable; + return this; + } + + @Override + public Grouped build() { + return new Grouped(this); + } + } + + public void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + var grouped = WeaviateProtoGenerative.GenerativeSearch.Grouped.newBuilder() + .setTask(prompt) + .setDebug(debug); + + if (properties != null && !properties.isEmpty()) { + grouped.setProperties( + WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(properties)); + + } + + var ragProviders = providers.stream() + .map(provider -> { + var proto = WeaviateProtoGenerative.GenerativeProvider.newBuilder(); + provider.appendTo(proto); + proto.setReturnMetadata(returnMetadata); + return proto.build(); + }) + .toList(); + grouped.addAllQueries(ragProviders); + + req.setGrouped(grouped); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/TaskOutput.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/TaskOutput.java new file mode 100644 index 000000000..379e7ebc7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/TaskOutput.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import io.weaviate.client6.v1.api.collections.generative.ProviderMetadata; + +public record TaskOutput( + String text, + ProviderMetadata metadata, + GenerativeDebug debug) { + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClient.java new file mode 100644 index 000000000..391007b5a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClient.java @@ -0,0 +1,37 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.GroupBy; +import io.weaviate.client6.v1.api.collections.query.QueryOperator; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateGenerateClient + extends + AbstractGenerateClient, GenerativeResponseGrouped> { + + public WeaviateGenerateClient( + CollectionDescriptor collection, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + super(collection, grpcTransport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateGenerateClient(WeaviateGenerateClient c, CollectionHandleDefaults defaults) { + super(c, defaults); + } + + @Override + protected final GenerativeResponse performRequest(QueryOperator operator, GenerativeTask generate) { + var request = new GenerativeRequest(operator, generate, null); + return this.grpcTransport.performRequest(request, GenerativeRequest.rpc(collection, defaults)); + } + + @Override + protected final GenerativeResponseGrouped performRequest(QueryOperator operator, GenerativeTask generate, + GroupBy groupBy) { + var request = new GenerativeRequest(operator, generate, groupBy); + return this.grpcTransport.performRequest(request, GenerativeRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClientAsync.java new file mode 100644 index 000000000..eff3866a7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generate/WeaviateGenerateClientAsync.java @@ -0,0 +1,41 @@ +package io.weaviate.client6.v1.api.collections.generate; + +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.query.GroupBy; +import io.weaviate.client6.v1.api.collections.query.QueryOperator; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateGenerateClientAsync + extends + AbstractGenerateClient>, CompletableFuture>> { + + public WeaviateGenerateClientAsync( + CollectionDescriptor collection, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + super(collection, grpcTransport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateGenerateClientAsync(WeaviateGenerateClientAsync c, CollectionHandleDefaults defaults) { + super(c, defaults); + } + + @Override + protected final CompletableFuture> performRequest(QueryOperator operator, + GenerativeTask generate) { + var request = new GenerativeRequest(operator, generate, null); + return this.grpcTransport.performRequestAsync(request, GenerativeRequest.rpc(collection, defaults)); + } + + @Override + protected final CompletableFuture> performRequest(QueryOperator operator, + GenerativeTask generate, + GroupBy groupBy) { + var request = new GenerativeRequest(operator, generate, groupBy); + return this.grpcTransport.performRequestAsync(request, GenerativeRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnthropicGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnthropicGenerative.java new file mode 100644 index 000000000..8cb2786fa --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnthropicGenerative.java @@ -0,0 +1,284 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record AnthropicGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("topK") Integer topK, + @SerializedName("topP") Float topP, + @SerializedName("stopSequences") List stopSequences) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.ANTHROPIC; + } + + @Override + public Object _self() { + return this; + } + + public static AnthropicGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static AnthropicGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public AnthropicGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.maxTokens, + builder.temperature, + builder.topK, + builder.topP, + builder.stopSequences); + } + + public static class Builder implements ObjectBuilder { + private Integer topK; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private String baseUrl; + private final List stopSequences = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AnthropicGenerative build() { + return new AnthropicGenerative(this); + } + } + + public static record Metadata(Usage usage) implements ProviderMetadata { + public static record Usage(Long inputTokens, Long outputTokens) { + } + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Integer topK, + Float topP, + List stopSequences, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeAnthropic.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topK != null) { + provider.setTopK(topK); + } + if (topP != null) { + provider.setTopP(topP); + } + + if (stopSequences != null) { + provider.setStopSequences(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + if (images != null) { + provider.setImages(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(images)); + } + if (imageProperties != null) { + provider.setImageProperties(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(imageProperties)); + } + req.setAnthropic(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.topK, + builder.topP, + builder.stopSequences, + builder.images, + builder.imageProperties); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer topK; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private final List stopSequences = new ArrayList<>(); + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AnthropicGenerative.Provider build() { + return new AnthropicGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnyscaleGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnyscaleGenerative.java new file mode 100644 index 000000000..f24d7fc34 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AnyscaleGenerative.java @@ -0,0 +1,140 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record AnyscaleGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("temperature") Float temperature) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.ANYSCALE; + } + + @Override + public Object _self() { + return this; + } + + public static AnyscaleGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static AnyscaleGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public AnyscaleGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.temperature); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Float temperature; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AnyscaleGenerative build() { + return new AnyscaleGenerative(this); + } + } + + public static record Metadata() implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + String model, + Float temperature) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeAnyscale.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + req.setAnyscale(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.temperature); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AnyscaleGenerative.Provider build() { + return new AnyscaleGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/AwsGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AwsGenerative.java new file mode 100644 index 000000000..0e3dd747f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AwsGenerative.java @@ -0,0 +1,367 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecAwsVectorizer.Service; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record AwsGenerative( + @SerializedName("region") String region, + @SerializedName("service") Service service, + @SerializedName("endpoint") String endpoint, + @SerializedName("model") String model, + @SerializedName("targetModel") String targetModel, + @SerializedName("targetVariant") String targetVariant, + @SerializedName("temperature") Float temperature, + @SerializedName("maxTokenCount") Integer maxTokenCount, + @SerializedName("maxTokensToSample") Integer maxTokensToSample, + @SerializedName("topP") Float topP, + @SerializedName("topK") Integer topK, + @SerializedName("stopSequences") List stopSequences) implements Generative { + + @Override + public Generative.Kind _kind() { + return Generative.Kind.AWS; + } + + @Override + public Object _self() { + return this; + } + + public static AwsGenerative bedrock(String region, String model) { + return bedrock(region, model, ObjectBuilder.identity()); + } + + public static AwsGenerative bedrock(String region, String model, + Function> fn) { + return fn.apply(new BedrockBuilder(region, model)).build(); + } + + public static AwsGenerative sagemaker(String region, String endpoint) { + return sagemaker(region, endpoint, ObjectBuilder.identity()); + } + + public static AwsGenerative sagemaker(String region, String endpoint, + Function> fn) { + return fn.apply(new SagemakerBuilder(region, endpoint)).build(); + } + + public AwsGenerative(Builder builder) { + this( + builder.region, + builder.service, + builder.endpoint, + builder.model, + builder.targetModel, + builder.targetVariant, + builder.temperature, + builder.maxTokenCount, + builder.maxTokensToSample, + builder.topP, + builder.topK, + builder.stopSequences); + } + + public static class Builder implements ObjectBuilder { + private final String region; + private final Service service; + + public Builder(Service service, String region) { + this.service = service; + this.region = region; + } + + private String endpoint; + private String model; + private String targetModel; + private String targetVariant; + private Float temperature; + private Integer maxTokenCount; + private Integer maxTokensToSample; + private Float topP; + private Integer topK; + private final List stopSequences = new ArrayList<>(); + + /** Base URL of the generative provider. */ + protected Builder endpoint(String endpoint) { + this.endpoint = endpoint; + return this; + } + + /** Select generative model. */ + protected Builder model(String model) { + this.model = model; + return this; + } + + /** Target model for Sagemaker. */ + public Builder targetModel(String targetModel) { + this.targetModel = targetModel; + return this; + } + + /** Target variant for Sagemaker. */ + public Builder targetVariant(String targetVariant) { + this.targetVariant = targetVariant; + return this; + } + + /** Control the randomness of the model's output. */ + public Builder temperature(Float temperature) { + this.temperature = temperature; + return this; + } + + /** Maximum number of tokens to generate. */ + public Builder maxTokenCount(Integer maxTokenCount) { + this.maxTokenCount = maxTokenCount; + return this; + } + + /** Maximum number of tokens to sample (for Anthropic models). */ + public Builder maxTokensToSample(Integer maxTokensToSample) { + this.maxTokensToSample = maxTokensToSample; + return this; + } + + /** Top-p sampling parameter. */ + public Builder topP(Float topP) { + this.topP = topP; + return this; + } + + /** Top-k sampling parameter. */ + public Builder topK(Integer topK) { + this.topK = topK; + return this; + } + + /** Stop sequences for the model. */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** Stop sequences for the model. */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + @Override + public AwsGenerative build() { + return new AwsGenerative(this); + } + } + + public static class BedrockBuilder extends Builder { + public BedrockBuilder(String region, String model) { + super(Service.BEDROCK, region); + super.model(model); + } + + @Override + /** Required for {@link Service#BEDROCK}. */ + public Builder model(String model) { + return super.model(model); + } + } + + public static class SagemakerBuilder extends Builder { + public SagemakerBuilder(String region, String endpoint) { + super(Service.SAGEMAKER, region); + super.endpoint(endpoint); + } + + /** Required for {@link Service#SAGEMAKER}. */ + public Builder endpoint(String endpoint) { + return super.endpoint(endpoint); + } + } + + public static record Metadata() implements ProviderMetadata { + } + + public static record Provider( + String region, + Service service, + String endpoint, + String model, + String targetModel, + String targetModelVariant, + Float temperature, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider bedrock( + String region, + String model, + Function> fn) { + return fn.apply(new BedrockBuilder(region, model)).build(); + } + + public static Provider sagemaker( + String region, + String endpoint, + Function> fn) { + return fn.apply(new SagemakerBuilder(region, endpoint)).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeAWS.newBuilder(); + if (region != null) { + provider.setRegion(region); + } + if (service != null) { + provider.setService( + service == Service.BEDROCK ? "bedrock" + : service == Service.SAGEMAKER ? "sagemaker" + : "unknown"); + } + if (endpoint != null) { + provider.setEndpoint(endpoint); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (targetModel != null) { + provider.setTargetModel(targetModel); + } + if (targetModelVariant != null) { + provider.setTargetVariant(targetModelVariant); + } + if (images != null) { + provider.setImages(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(images)); + } + if (imageProperties != null) { + provider.setImageProperties(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(imageProperties)); + } + req.setAws(provider); + } + + public Provider(Builder builder) { + this( + builder.region, + builder.service, + builder.endpoint, + builder.model, + builder.targetModel, + builder.targetModelVariant, + builder.temperature, + builder.images, + builder.imageProperties); + } + + public abstract static class Builder implements ObjectBuilder { + private final Service service; + private final String region; + private String endpoint; + private String model; + private String targetModel; + private String targetModelVariant; + private Float temperature; + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + protected Builder(Service service, String region) { + this.service = service; + this.region = region; + } + + /** Base URL of the generative provider. */ + protected Builder endpoint(String endpoint) { + this.endpoint = endpoint; + return this; + } + + /** Select generative model. */ + protected Builder model(String model) { + this.model = model; + return this; + } + + public Builder targetModel(String targetModel) { + this.targetModel = targetModel; + return this; + } + + public Builder targetModelVariant(String targetModelVariant) { + this.targetModelVariant = targetModelVariant; + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AwsGenerative.Provider build() { + return new AwsGenerative.Provider(this); + } + } + + public static class BedrockBuilder extends Builder { + public BedrockBuilder(String region, String model) { + super(Service.BEDROCK, region); + super.model(model); + } + + @Override + /** Required for {@link Service#BEDROCK}. */ + public Builder model(String model) { + return super.model(model); + } + } + + public static class SagemakerBuilder extends Builder { + public SagemakerBuilder(String region, String endpoint) { + super(Service.SAGEMAKER, region); + super.endpoint(endpoint); + } + + /** Required for {@link Service#SAGEMAKER}. */ + public Builder endpoint(String endpoint) { + return super.endpoint(endpoint); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/AzureOpenAiGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AzureOpenAiGenerative.java new file mode 100644 index 000000000..cce9ad86c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/AzureOpenAiGenerative.java @@ -0,0 +1,338 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record AzureOpenAiGenerative( + @SerializedName("apiVersion") String apiVersion, + @SerializedName("baseURL") String baseUrl, + @SerializedName("frequencyPenalty") Float frequencyPenalty, + @SerializedName("presencePenalty") Float presencePenalty, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("topP") Float topP, + @SerializedName("model") String model, + + @SerializedName("resourceName") String resourceName, + @SerializedName("deploymentId") String deploymentId) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.AZURE_OPENAI; + } + + @Override + public Object _self() { + return this; + } + + public static AzureOpenAiGenerative of(String resourceName, String deploymentId) { + return of(resourceName, deploymentId, ObjectBuilder.identity()); + } + + public static AzureOpenAiGenerative of(String resourceName, String deploymentId, + Function> fn) { + return fn.apply(new Builder(resourceName, deploymentId)).build(); + } + + public AzureOpenAiGenerative(Builder builder) { + this( + builder.apiVersion, + builder.baseUrl, + builder.frequencyPenalty, + builder.presencePenalty, + builder.maxTokens, + builder.temperature, + builder.topP, + builder.model, + builder.resourceName, + builder.deploymentId); + } + + public static class Builder implements ObjectBuilder { + private final String resourceName; + private final String deploymentId; + + private String apiVersion; + private String baseUrl; + private Float frequencyPenalty; + private Float presencePenalty; + private Integer maxTokens; + private Float temperature; + private Float topP; + private String model; + + public Builder(String resourceName, String deploymentId) { + this.resourceName = resourceName; + this.deploymentId = deploymentId; + } + + /** API version for the generative provider. */ + public Builder apiVersion(String apiVersion) { + this.apiVersion = apiVersion; + return this; + } + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + @Override + public AzureOpenAiGenerative build() { + return new AzureOpenAiGenerative(this); + } + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Integer n, + Float topP, + Float frequencyPenalty, + Float presencePenalty, + String apiVersion, + String resourceName, + String deploymentId, + List stopSequences, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeOpenAI.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (n != null) { + provider.setN(n); + } + if (topP != null) { + provider.setTopP(topP); + } + if (frequencyPenalty != null) { + provider.setFrequencyPenalty(frequencyPenalty); + } + if (presencePenalty != null) { + provider.setPresencePenalty(presencePenalty); + } + if (apiVersion != null) { + provider.setApiVersion(apiVersion); + } + if (resourceName != null) { + provider.setResourceName(resourceName); + } + if (deploymentId != null) { + provider.setDeploymentId(deploymentId); + } + if (stopSequences != null) { + provider.setStop(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + provider.setIsAzure(true); + req.setOpenai(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.n, + builder.topP, + builder.frequencyPenalty, + builder.presencePenalty, + builder.apiVersion, + builder.resourceName, + builder.deploymentId, + builder.stopSequences, + builder.images, + builder.imageProperties); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer n; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private Float frequencyPenalty; + private Float presencePenalty; + private String apiVersion; + private String resourceName; + private String deploymentId; + private final List stopSequences = new ArrayList<>(); + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder n(int n) { + this.n = n; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + public Builder apiVersion(String apiVersion) { + this.apiVersion = apiVersion; + return this; + } + + public Builder resourceName(String resourceName) { + this.resourceName = resourceName; + return this; + } + + public Builder deploymentId(String deploymentId) { + this.deploymentId = deploymentId; + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public AzureOpenAiGenerative.Provider build() { + return new AzureOpenAiGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/CohereGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/CohereGenerative.java new file mode 100644 index 000000000..2811a61b6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/CohereGenerative.java @@ -0,0 +1,309 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record CohereGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("k") Integer topK, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("returnLikelihoods") String returnLikelihoodsProperty, + @SerializedName("stopSequences") List stopSequences, + @SerializedName("P") Float topP, + @SerializedName("presencePenalty") Float presencePenalty, + @SerializedName("frequencyPenalty") Float frequencyPenalty) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.COHERE; + } + + @Override + public Object _self() { + return this; + } + + public static CohereGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static CohereGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public CohereGenerative(Builder builder) { + this( + builder.baseUrl, + builder.topK, + builder.model, + builder.maxTokens, + builder.temperature, + builder.returnLikelihoodsProperty, + builder.stopSequences, + builder.topP, + builder.presencePenalty, + builder.frequencyPenalty); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer topK; + private String model; + private Integer maxTokens; + private Float temperature; + private String returnLikelihoodsProperty; + private final List stopSequences = new ArrayList<>(); + private Float topP; + private Float presencePenalty; + private Float frequencyPenalty; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + public Builder returnLikelihoodsProperty(String returnLikelihoodsProperty) { + this.returnLikelihoodsProperty = returnLikelihoodsProperty; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + @Override + public CohereGenerative build() { + return new CohereGenerative(this); + } + } + + public static record Metadata(ApiVersion apiVersion, BilledUnits billedUnits, Tokens tokens, List warnings) + implements ProviderMetadata { + + public static record ApiVersion(String version, Boolean deprecated, Boolean experimental) { + } + + public static record BilledUnits(Double inputTokens, Double outputTokens, Double searchUnits, + Double classifications) { + } + + public static record Tokens(Double inputTokens, Double outputTokens) { + } + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Integer topK, + Float topP, + Float frequencyPenalty, + Float presencePenalty, + List stopSequences) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeCohere.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topK != null) { + provider.setK(topK); + } + if (topP != null) { + provider.setP(topP); + } + + if (frequencyPenalty != null) { + provider.setFrequencyPenalty(frequencyPenalty); + } + if (presencePenalty != null) { + provider.setPresencePenalty(presencePenalty); + } + + if (stopSequences != null) { + provider.setStopSequences(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + req.setCohere(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.topK, + builder.topP, + builder.frequencyPenalty, + builder.presencePenalty, + builder.stopSequences); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer topK; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private Float frequencyPenalty; + private Float presencePenalty; + private final List stopSequences = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public CohereGenerative.Provider build() { + return new CohereGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/DatabricksGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/DatabricksGenerative.java new file mode 100644 index 000000000..2740a3b4b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/DatabricksGenerative.java @@ -0,0 +1,265 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record DatabricksGenerative( + @SerializedName("endpoint") String endpoint, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("topK") Integer topK, + @SerializedName("topP") Float topP, + @SerializedName("temperature") Float temperature) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.DATABRICKS; + } + + @Override + public Object _self() { + return this; + } + + public static DatabricksGenerative of(String endpoint) { + return of(endpoint, ObjectBuilder.identity()); + } + + public static DatabricksGenerative of(String endpoint, Function> fn) { + return fn.apply(new Builder(endpoint)).build(); + } + + public DatabricksGenerative(Builder builder) { + this( + builder.endpoint, + builder.maxTokens, + builder.topK, + builder.topP, + builder.temperature); + } + + public static class Builder implements ObjectBuilder { + private final String endpoint; + + private Integer maxTokens; + private Integer topK; + private Float topP; + private Float temperature; + + public Builder(String endpoint) { + this.endpoint = endpoint; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public DatabricksGenerative build() { + return new DatabricksGenerative(this); + } + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String endpoint, + Integer maxTokens, + String model, + Float temperature, + Integer n, + Float topP, + Float frequencyPenalty, + Float presencePenalty, + Boolean logProbs, + Integer topLogProbs, + List stopSequences) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeDatabricks.newBuilder(); + if (endpoint != null) { + provider.setEndpoint(endpoint); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (n != null) { + provider.setN(n); + } + if (topP != null) { + provider.setTopP(topP); + } + if (frequencyPenalty != null) { + provider.setFrequencyPenalty(frequencyPenalty); + } + if (presencePenalty != null) { + provider.setPresencePenalty(presencePenalty); + } + if (logProbs != null) { + provider.setLogProbs(logProbs); + } + if (topLogProbs != null) { + provider.setTopLogProbs(topLogProbs); + } + if (stopSequences != null) { + provider.setStop(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + req.setDatabricks(provider); + } + + public Provider(Builder builder) { + this( + builder.endpoint, + builder.maxTokens, + builder.model, + builder.temperature, + builder.n, + builder.topP, + builder.frequencyPenalty, + builder.presencePenalty, + builder.logProbs, + builder.topLogProbs, + builder.stopSequences); + } + + public static class Builder implements ObjectBuilder { + private String endpoint; + private Integer n; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private Float frequencyPenalty; + private Float presencePenalty; + private Boolean logProbs; + private Integer topLogProbs; + private final List stopSequences = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder endpoint(String endpoint) { + this.endpoint = endpoint; + return this; + } + + public Builder n(int n) { + this.n = n; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + public Builder logProbs(boolean logProbs) { + this.logProbs = logProbs; + return this; + } + + public Builder topLogProbs(int topLogProbs) { + this.topLogProbs = topLogProbs; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public DatabricksGenerative.Provider build() { + return new DatabricksGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/DummyGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/DummyGenerative.java new file mode 100644 index 000000000..8f45163fe --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/DummyGenerative.java @@ -0,0 +1,18 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import io.weaviate.client6.v1.api.collections.Generative; + +public record DummyGenerative() implements Generative { + @Override + public Kind _kind() { + return Generative.Kind.DUMMY; + } + + @Override + public Object _self() { + return this; + } + + public static record Metadata() implements ProviderMetadata { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/FriendliaiGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/FriendliaiGenerative.java new file mode 100644 index 000000000..a42080249 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/FriendliaiGenerative.java @@ -0,0 +1,186 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record FriendliaiGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.FRIENDLIAI; + } + + @Override + public Object _self() { + return this; + } + + public static FriendliaiGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static FriendliaiGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public FriendliaiGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.maxTokens, + builder.temperature); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Integer maxTokens; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public FriendliaiGenerative build() { + return new FriendliaiGenerative(this); + } + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Integer n, + Float topP) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeFriendliAI.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (n != null) { + provider.setN(n); + } + if (topP != null) { + provider.setTopP(topP); + } + req.setFriendliai(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.n, + builder.topP); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer n; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder n(int n) { + this.n = n; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public FriendliaiGenerative.Provider build() { + return new FriendliaiGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/GoogleGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/GoogleGenerative.java new file mode 100644 index 000000000..8a34921d3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/GoogleGenerative.java @@ -0,0 +1,407 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecGoogleVectorizer; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record GoogleGenerative( + @SerializedName("apiEndpoint") String apiEndpoint, + @SerializedName("modelId") String modelId, + @SerializedName("projectId") String projectId, + @SerializedName("endpointId") String endpointId, + @SerializedName("region") String region, + @SerializedName("model") String model, + @SerializedName("maxOutputTokens") Integer maxTokens, + @SerializedName("topK") Integer topK, + @SerializedName("topP") Float topP, + @SerializedName("temperature") Float temperature) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.GOOGLE; + } + + @Override + public Object _self() { + return this; + } + + public static GoogleGenerative aiStudio() { + return aiStudio(ObjectBuilder.identity()); + } + + public static GoogleGenerative aiStudio(Function> fn) { + return fn.apply(new AiStudioBuilder()).build(); + } + + public static GoogleGenerative vertex(String projectId) { + return vertex(projectId, ObjectBuilder.identity()); + } + + public static GoogleGenerative vertex(String projectId, Function> fn) { + return fn.apply(new VertexBuilder(projectId)).build(); + } + + public GoogleGenerative(Builder builder) { + this( + builder.apiEndpoint, + builder.modelId, + builder.projectId, + builder.endpointId, + builder.region, + builder.model, + builder.maxTokens, + builder.topK, + builder.topP, + builder.temperature); + } + + public abstract static class Builder implements ObjectBuilder { + private String apiEndpoint; + private final String projectId; + + private String modelId; + private String endpointId; + private String region; + private String model; + private Integer maxTokens; + private Integer topK; + private Float topP; + private Float temperature; + + public Builder(String apiEndpoint, String projectId) { + this.projectId = projectId; + this.apiEndpoint = apiEndpoint; + } + + /** Base URL of the generative provider. */ + protected Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + /** Select generative model. */ + public Builder modelId(String modelId) { + this.modelId = modelId; + return this; + } + + /** Endpoint ID for Vertex AI. */ + public Builder endpointId(String endpointId) { + this.endpointId = endpointId; + return this; + } + + /** Google region. */ + public Builder region(String region) { + this.region = region; + return this; + } + + /** Generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Top K value for sampling. */ + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public GoogleGenerative build() { + return new GoogleGenerative(this); + } + } + + public static class AiStudioBuilder extends Builder { + public AiStudioBuilder() { + super(Text2VecGoogleVectorizer.AiStudioBuilder.BASE_URL, null); + } + } + + public static class VertexBuilder extends Builder { + public VertexBuilder(String projectId) { + super(Text2VecGoogleVectorizer.VertexBuilder.DEFAULT_BASE_URL, projectId); + } + + /** Base URL of the generative provider. */ + public VertexBuilder apiEndpoint(String apiEndpoint) { + super.apiEndpoint(apiEndpoint); + return this; + } + } + + public static record Metadata(TokenMetadata tokens, Usage usage) implements ProviderMetadata { + + public static record TokenCount(Long totalBillableCharacters, Long totalTokens) { + } + + public static record TokenMetadata(TokenCount inputTokens, TokenCount outputTokens) { + } + + public static record Usage(Long promptTokenCount, Long candidatesTokenCount, Long totalTokenCount) { + } + } + + public static record Provider( + String apiEndpoint, + Integer maxTokens, + String modelId, + Float temperature, + Integer topK, + Float topP, + Float frequencyPenalty, + Float presencePenalty, + String projectId, + String endpointId, + String region, + List stopSequences, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider vertex( + String projectId, + Function> fn) { + return fn.apply(new VertexBuilder(projectId)).build(); + } + + public static Provider aiStudio( + Function> fn) { + return fn.apply(new AiStudioBuilder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeGoogle.newBuilder(); + if (apiEndpoint != null) { + provider.setApiEndpoint(apiEndpoint); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (modelId != null) { + provider.setModel(modelId); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topK != null) { + provider.setTopK(topK); + } + if (topP != null) { + provider.setTopP(topP); + } + if (projectId != null) { + provider.setProjectId(projectId); + } + if (endpointId != null) { + provider.setEndpointId(endpointId); + } + if (region != null) { + provider.setRegion(region); + } + if (frequencyPenalty != null) { + provider.setFrequencyPenalty(frequencyPenalty); + } + if (presencePenalty != null) { + provider.setPresencePenalty(presencePenalty); + } + if (stopSequences != null) { + provider.setStopSequences(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + req.setGoogle(provider); + } + + public Provider(Builder builder) { + this( + builder.apiEndpoint, + builder.maxTokens, + builder.modelId, + builder.temperature, + builder.topK, + builder.topP, + builder.frequencyPenalty, + builder.presencePenalty, + builder.projectId, + builder.endpointId, + builder.region, + builder.stopSequences, + builder.images, + builder.imageProperties); + } + + public abstract static class Builder implements ObjectBuilder { + private final String projectId; + private String apiEndpoint; + + private Integer topK; + private Float topP; + private String modelId; + private Integer maxTokens; + private Float temperature; + private Float frequencyPenalty; + private Float presencePenalty; + private String endpointId; + private String region; + private final List stopSequences = new ArrayList<>(); + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + public Builder(String apiEndpoint, String projectId) { + this.projectId = projectId; + this.apiEndpoint = apiEndpoint; + } + + /** Base URL of the generative provider. */ + protected Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + public Builder topK(int topK) { + this.topK = topK; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Select generative model. */ + public Builder modelId(String modelId) { + this.modelId = modelId; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + public Builder endpointId(String endpointId) { + this.endpointId = endpointId; + return this; + } + + public Builder region(String region) { + this.region = region; + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public GoogleGenerative.Provider build() { + return new GoogleGenerative.Provider(this); + } + } + + public static class AiStudioBuilder extends Builder { + public AiStudioBuilder() { + super(Text2VecGoogleVectorizer.AiStudioBuilder.BASE_URL, null); + } + } + + public static class VertexBuilder extends Builder { + public VertexBuilder(String projectId) { + super(Text2VecGoogleVectorizer.VertexBuilder.DEFAULT_BASE_URL, projectId); + } + + /** Base URL of the generative provider. */ + public VertexBuilder apiEndpoint(String apiEndpoint) { + super.apiEndpoint(apiEndpoint); + return this; + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/MistralGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/MistralGenerative.java new file mode 100644 index 000000000..7366f146f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/MistralGenerative.java @@ -0,0 +1,175 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record MistralGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.MISTRAL; + } + + @Override + public Object _self() { + return this; + } + + public static MistralGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static MistralGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public MistralGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.maxTokens, + builder.temperature); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Integer maxTokens; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public MistralGenerative build() { + return new MistralGenerative(this); + } + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Float topP) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeMistral.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topP != null) { + provider.setTopP(topP); + } + req.setMistral(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.topP); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public MistralGenerative.Provider build() { + return new MistralGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/NvidiaGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/NvidiaGenerative.java new file mode 100644 index 000000000..f88b5bb70 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/NvidiaGenerative.java @@ -0,0 +1,184 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record NvidiaGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("topP") Float topP) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.NVIDIA; + } + + @Override + public Object _self() { + return this; + } + + public static NvidiaGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static NvidiaGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public NvidiaGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.maxTokens, + builder.temperature, + builder.topP); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Integer maxTokens; + private Float temperature; + private Float topP; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + /** Top P value for sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + @Override + public NvidiaGenerative build() { + return new NvidiaGenerative(this); + } + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Float topP) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeNvidia.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topP != null) { + provider.setTopP(topP); + } + req.setNvidia(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.topP); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public NvidiaGenerative.Provider build() { + return new NvidiaGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/OllamaGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/OllamaGenerative.java new file mode 100644 index 000000000..e108eed01 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/OllamaGenerative.java @@ -0,0 +1,166 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record OllamaGenerative( + @SerializedName("apiEndpoint") String apiEndpoint, + @SerializedName("model") String model) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.OLLAMA; + } + + @Override + public Object _self() { + return this; + } + + public static OllamaGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static OllamaGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public OllamaGenerative(Builder builder) { + this( + builder.apiEndpoint, + builder.model); + } + + public static class Builder implements ObjectBuilder { + private String apiEndpoint; + private String model; + + /** Base URL of the generative model. */ + public Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + @Override + public OllamaGenerative build() { + return new OllamaGenerative(this); + } + } + + public static record Metadata() implements ProviderMetadata { + } + + public static record Provider( + String apiEndpoint, + String model, + Float temperature, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeOllama.newBuilder(); + if (apiEndpoint != null) { + provider.setApiEndpoint(apiEndpoint); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (images != null) { + provider.setImages(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(images)); + } + if (imageProperties != null) { + provider.setImageProperties(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(imageProperties)); + } + req.setOllama(provider); + } + + public Provider(Builder builder) { + this( + builder.apiEndpoint, + builder.model, + builder.temperature, + builder.images, + builder.imageProperties); + } + + public static class Builder implements ObjectBuilder { + private String apiEndpoint; + private String model; + private Float temperature; + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public OllamaGenerative.Provider build() { + return new OllamaGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/OpenAiGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/OpenAiGenerative.java new file mode 100644 index 000000000..670abefca --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/OpenAiGenerative.java @@ -0,0 +1,332 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record OpenAiGenerative( + @SerializedName("apiVersion") String apiVersion, + @SerializedName("baseURL") String baseUrl, + @SerializedName("frequencyPenalty") Float frequencyPenalty, + @SerializedName("presencePenalty") Float presencePenalty, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("topP") Float topP, + @SerializedName("model") String model, + @SerializedName("reasoningEffort") ReasoningEffort reasoningEffort, + @SerializedName("verbosity") Verbosity verbosity) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.OPENAI; + } + + @Override + public Object _self() { + return this; + } + + public static OpenAiGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static OpenAiGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public OpenAiGenerative(Builder builder) { + this( + builder.apiVersion, + builder.baseUrl, + builder.frequencyPenalty, + builder.presencePenalty, + builder.maxTokens, + builder.temperature, + builder.topP, + builder.model, + builder.reasoningEffort, + builder.verbosity); + } + + public static class Builder implements ObjectBuilder { + private String apiVersion; + private String baseUrl; + private Float frequencyPenalty; + private Float presencePenalty; + private Integer maxTokens; + private Float temperature; + private Float topP; + private String model; + private ReasoningEffort reasoningEffort; + private Verbosity verbosity; + + /** API version for the generative provider. */ + public Builder apiVersion(String apiVersion) { + this.apiVersion = apiVersion; + return this; + } + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Set the reasoning effort level. */ + public Builder reasoningEffort(ReasoningEffort reasoningEffort) { + this.reasoningEffort = reasoningEffort; + return this; + } + + /** Set the verbosity level. */ + public Builder verbosity(Verbosity verbosity) { + this.verbosity = verbosity; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + @Override + public OpenAiGenerative build() { + return new OpenAiGenerative(this); + } + } + + public enum ReasoningEffort { + @SerializedName("minimal") + MINIMAL, + @SerializedName("low") + LOW, + @SerializedName("medium") + MEDIUM, + @SerializedName("high") + HIGH; + } + + public enum Verbosity { + @SerializedName("low") + LOW, + @SerializedName("medium") + MEDIUM, + @SerializedName("high") + HIGH; + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Integer n, + Float topP, + Float frequencyPenalty, + Float presencePenalty, + List stopSequences, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeOpenAI.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (n != null) { + provider.setN(n); + } + if (topP != null) { + provider.setTopP(topP); + } + if (frequencyPenalty != null) { + provider.setFrequencyPenalty(frequencyPenalty); + } + if (presencePenalty != null) { + provider.setPresencePenalty(presencePenalty); + } + if (stopSequences != null) { + provider.setStop(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(stopSequences)); + } + provider.setIsAzure(false); + req.setOpenai(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.n, + builder.topP, + builder.frequencyPenalty, + builder.presencePenalty, + builder.stopSequences, + builder.images, + builder.imageProperties); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Integer n; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private Float frequencyPenalty; + private Float presencePenalty; + private final List stopSequences = new ArrayList<>(); + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder n(int n) { + this.n = n; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + public Builder frequencyPenalty(float frequencyPenalty) { + this.frequencyPenalty = frequencyPenalty; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder presencePenalty(float presencePenalty) { + this.presencePenalty = presencePenalty; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(String... stopSequences) { + return stopSequences(Arrays.asList(stopSequences)); + } + + /** + * Set tokens which should signal the model to stop generating further output. + */ + public Builder stopSequences(List stopSequences) { + this.stopSequences.addAll(stopSequences); + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public OpenAiGenerative.Provider build() { + return new OpenAiGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/ProviderMetadata.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/ProviderMetadata.java new file mode 100644 index 000000000..884dd6dd3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/ProviderMetadata.java @@ -0,0 +1,9 @@ +package io.weaviate.client6.v1.api.collections.generative; + +public interface ProviderMetadata { + record Usage( + Long promptTokens, + Long completionTokens, + Long totalTokens) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/generative/XaiGenerative.java b/src/main/java/io/weaviate/client6/v1/api/collections/generative/XaiGenerative.java new file mode 100644 index 000000000..c1d271f5a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/generative/XaiGenerative.java @@ -0,0 +1,220 @@ +package io.weaviate.client6.v1.api.collections.generative; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.generate.GenerativeProvider; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record XaiGenerative( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("maxTokens") Integer maxTokens, + @SerializedName("temperature") Float temperature, + @SerializedName("topP") Float topP) implements Generative { + + @Override + public Kind _kind() { + return Generative.Kind.XAI; + } + + @Override + public Object _self() { + return this; + } + + public static XaiGenerative of() { + return of(ObjectBuilder.identity()); + } + + public static XaiGenerative of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public XaiGenerative(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.maxTokens, + builder.temperature, + builder.topP); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private String model; + private Integer maxTokens; + private Float temperature; + private Float topP; + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + /** Top P value for sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + @Override + public XaiGenerative build() { + return new XaiGenerative(this); + } + } + + public static record Metadata(ProviderMetadata.Usage usage) implements ProviderMetadata { + } + + public static record Provider( + String baseUrl, + Integer maxTokens, + String model, + Float temperature, + Float topP, + List images, + List imageProperties) implements GenerativeProvider { + + public static Provider of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + @Override + public void appendTo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder req) { + var provider = WeaviateProtoGenerative.GenerativeXAI.newBuilder(); + if (baseUrl != null) { + provider.setBaseUrl(baseUrl); + } + if (maxTokens != null) { + provider.setMaxTokens(maxTokens); + } + if (model != null) { + provider.setModel(model); + } + if (temperature != null) { + provider.setTemperature(temperature); + } + if (topP != null) { + provider.setTopP(topP); + } + if (images != null) { + provider.setImages(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(images)); + } + if (imageProperties != null) { + provider.setImageProperties(WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(imageProperties)); + } + req.setXai(provider); + } + + public Provider(Builder builder) { + this( + builder.baseUrl, + builder.maxTokens, + builder.model, + builder.temperature, + builder.topP, + builder.images, + builder.imageProperties); + } + + public static class Builder implements ObjectBuilder { + private String baseUrl; + private Float topP; + private String model; + private Integer maxTokens; + private Float temperature; + private final List images = new ArrayList<>(); + private final List imageProperties = new ArrayList<>(); + + /** Base URL of the generative provider. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Top P value for nucleus sampling. */ + public Builder topP(float topP) { + this.topP = topP; + return this; + } + + /** Select generative model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Limit the number of tokens to generate in the response. */ + public Builder maxTokens(int maxTokens) { + this.maxTokens = maxTokens; + return this; + } + + public Builder images(String... images) { + return images(Arrays.asList(images)); + } + + public Builder images(List images) { + this.images.addAll(images); + return this; + } + + public Builder imageProperties(String... imageProperties) { + return imageProperties(Arrays.asList(imageProperties)); + } + + public Builder imageProperties(List imageProperties) { + this.imageProperties.addAll(imageProperties); + return this; + } + + /** + * Control the randomness of the model's output. + * Higher values make output more random. + */ + public Builder temperature(float temperature) { + this.temperature = temperature; + return this; + } + + @Override + public XaiGenerative.Provider build() { + return new XaiGenerative.Provider(this); + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPage.java b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPage.java new file mode 100644 index 000000000..6a4f1bdc0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPage.java @@ -0,0 +1,74 @@ +package io.weaviate.client6.v1.api.collections.pagination; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.function.BiFunction; + +import io.weaviate.client6.v1.api.collections.WeaviateObject; + +public final class AsyncPage implements Iterable> { + + private final int pageSize; + private final BiFunction>>> fetch; + + private final String cursor; + private List> currentPage = new ArrayList<>(); + + AsyncPage(String cursor, int pageSize, + BiFunction>>> fetch) { + this.cursor = cursor; + this.pageSize = pageSize; + this.fetch = fetch; + } + + AsyncPage(String cursor, int pageSize, + BiFunction>>> fetch, + List> currentPage) { + this(cursor, pageSize, fetch); + this.currentPage = Collections.unmodifiableList(currentPage); + } + + List> items() { + return currentPage; + } + + public boolean isEmpty() { + return this.currentPage.isEmpty(); + } + + /** + * Fetch an {@link AsyncPage} containing the next {@code pageSize} results + * and advance the cursor. + * + *

+ * The returned stage may complete exceptionally in case the underlying + * query fails. Callers are advised to use exception-aware + * {@link CompletableFuture#handle} to process page results. + */ + public CompletableFuture> fetchNextPage() { + return fetch.apply(cursor, pageSize) + .thenApply(nextPage -> { + if (nextPage.isEmpty()) { + return new AsyncPage<>(null, pageSize, fetch, nextPage); + } + var last = nextPage.get(nextPage.size() - 1); + var nextCursor = last.uuid(); + // The cursor can only be null on the first iteration. + // If it is null after the first iteration it is + // because we haven't requested Metadata.UUID, in which + // case pagination will continue to run unbounded. + if (nextCursor == null) { + throw new IllegalStateException("page cursor is null"); + } + return new AsyncPage<>(nextCursor, pageSize, fetch, nextPage); + }); + } + + @Override + public Iterator> iterator() { + return currentPage.iterator(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPaginator.java b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPaginator.java new file mode 100644 index 000000000..caa321837 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/AsyncPaginator.java @@ -0,0 +1,167 @@ +package io.weaviate.client6.v1.api.collections.pagination; + +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.function.Consumer; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.query.FetchObjects; +import io.weaviate.client6.v1.api.collections.query.Metadata; +import io.weaviate.client6.v1.api.collections.query.QueryReference; +import io.weaviate.client6.v1.api.collections.query.QueryResponse; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClientAsync; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public class AsyncPaginator { + private final WeaviateQueryClientAsync query; + private final Function> queryOptions; + private final int pageSize; + private final String cursor; + + private CompletableFuture> resultSet; + + public AsyncPaginator(Builder builder) { + this.query = builder.query; + this.queryOptions = builder.queryOptions; + this.pageSize = builder.pageSize; + this.cursor = builder.cursor; + + var rs = new AsyncPage( + cursor, + pageSize, + (cursor, pageSize) -> { + var fn = ObjectBuilder.partial(queryOptions, q -> q.after(cursor).limit(pageSize)); + return this.query.fetchObjects(fn) + .handle((response, ex) -> { + if (ex != null) { + throw PaginationException.after(cursor, pageSize, ex); + } + return response; + }) + .thenApply(QueryResponse::objects); + }); + + this.resultSet = builder.prefetch ? rs.fetchNextPage() : CompletableFuture.completedFuture(rs); + } + + public CompletableFuture forEach(Consumer> action) { + return resultSet + .thenCompose(rs -> rs.isEmpty() ? rs.fetchNextPage() : CompletableFuture.completedFuture(rs)) + .thenCompose(processEachAndAdvance(action)); + } + + public CompletableFuture forPage(Consumer>> action) { + return resultSet + .thenCompose(rs -> rs.isEmpty() ? rs.fetchNextPage() : CompletableFuture.completedFuture(rs)) + .thenCompose(processPageAndAdvance(action)); + } + + private static Function, CompletableFuture> processEachAndAdvance( + Consumer> action) { + return processAndAdvanceFunc(rs -> rs.forEach(action)); + } + + private static Function, CompletableFuture> processPageAndAdvance( + Consumer>> action) { + return processAndAdvanceFunc(rs -> action.accept(rs.items())); + } + + private static Function, CompletableFuture> processAndAdvanceFunc( + Consumer> action) { + return rs -> { + // Empty result set means there were no more objects to fetch. + if (rs.isEmpty()) { + return CompletableFuture.completedFuture(null); + } + + // Apply provided callback for each method -- consume current page. + action.accept(rs); + + // Advance iteration. + return rs.fetchNextPage().thenCompose(processAndAdvanceFunc(action)); + }; + } + + public static AsyncPaginator of(WeaviateQueryClientAsync query) { + return of(query, ObjectBuilder.identity()); + } + + public static AsyncPaginator of(WeaviateQueryClientAsync query, + Function, ObjectBuilder>> fn) { + return fn.apply(new Builder<>(query)).build(); + } + + public static class Builder implements ObjectBuilder> { + private final WeaviateQueryClientAsync query; + + private Function> queryOptions = ObjectBuilder.identity(); + private int pageSize = Paginator.DEFAULT_PAGE_SIZE; + private String cursor; + private boolean prefetch = false; + + public Builder(WeaviateQueryClientAsync query) { + this.query = query; + } + + // Pagination options ----------------------------------------------------- + + public Builder pageSize(int pageSize) { + this.pageSize = pageSize; + return this; + } + + /** Set a cursor (object UUID) to start pagination from. */ + public Builder fromCursor(String uuid) { + this.cursor = uuid; + return this; + } + + /** + * When prefetch is enabled, the first page is retrieved before any of the + * terminating methods ({@link AsyncPaginator#forEach}, + * {@link AsyncPaginator#forPage}) are called on the paginator. + */ + public Builder prefetch(boolean enable) { + this.prefetch = enable; + return this; + } + + // Query options ---------------------------------------------------------- + + public final Builder returnProperties(String... properties) { + return applyQueryOption(q -> q.returnProperties(properties)); + } + + public final Builder returnProperties(List properties) { + return applyQueryOption(q -> q.returnProperties(properties)); + } + + public final Builder returnReferences(QueryReference... references) { + return applyQueryOption(q -> q.returnReferences(references)); + } + + public final Builder returnReferences(List references) { + return applyQueryOption(q -> q.returnReferences(references)); + } + + public final Builder returnMetadata(Metadata... metadata) { + return applyQueryOption(q -> q.returnMetadata(metadata)); + } + + public final Builder returnMetadata(List metadata) { + return applyQueryOption(q -> q.returnMetadata(metadata)); + } + + private final Builder applyQueryOption( + Function> options) { + this.queryOptions = ObjectBuilder.partial(this.queryOptions, options); + return this; + } + + @Override + public AsyncPaginator build() { + return new AsyncPaginator<>(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/pagination/CursorSpliterator.java b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/CursorSpliterator.java new file mode 100644 index 000000000..815b01714 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/CursorSpliterator.java @@ -0,0 +1,72 @@ +package io.weaviate.client6.v1.api.collections.pagination; + +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Spliterator; +import java.util.function.BiFunction; +import java.util.function.Consumer; + +import io.weaviate.client6.v1.api.collections.WeaviateObject; + +public class CursorSpliterator implements Spliterator> { + private final int pageSize; + private final BiFunction>> fetch; + + // Spliterators do not promise thread-safety, so there's no mechanism + // to protect access to its internal state. + private String cursor; + private Iterator> currentPage = Collections.emptyIterator(); + + public CursorSpliterator(String cursor, int pageSize, + BiFunction>> fetch) { + this.cursor = cursor; + this.pageSize = pageSize; + this.fetch = fetch; + } + + @Override + public boolean tryAdvance(Consumer> action) { + // Happy path: there are remaining objects in the current page. + if (currentPage.hasNext()) { + action.accept(currentPage.next()); + return true; + } + + // It's OK for the cursor to be null, because it's String (object). + var nextPage = fetch.apply(cursor, pageSize); + if (nextPage.isEmpty()) { + return false; + } + cursor = nextPage.get(nextPage.size() - 1).uuid(); + + // The cursor can only be null on the first iteration. + // If it is null after the first iteration it is + // because we haven't requested Metadata.UUID, in which + // case pagination will continue to run unbounded. + if (cursor == null) { + throw new IllegalStateException("page cursor is null"); + } + + currentPage = nextPage.iterator(); + return tryAdvance(action); + } + + @Override + public Spliterator> trySplit() { + // Do not support splitting just now; + return null; + } + + @Override + public long estimateSize() { + // CursorSpliterator does not have SIZED characteristic, so this is our + // best-effort estimate. The number of objects in the db is unbounded. + return Long.MAX_VALUE; + } + + @Override + public int characteristics() { + return ORDERED | DISTINCT | NONNULL; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/pagination/PaginationException.java b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/PaginationException.java new file mode 100644 index 000000000..27a119f59 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/PaginationException.java @@ -0,0 +1,33 @@ +package io.weaviate.client6.v1.api.collections.pagination; + +import io.weaviate.client6.v1.api.WeaviateException; + +/** + * WeaviatePaginationException is thrown then the client encouters an exception + * while fetching the next page. This exception preserves the original exception + * (see {@link #getCause} and the information about the last cursor and page + * size used (see {@link #cursor()} and {@link #pageSize()} respectively). + */ +public class PaginationException extends WeaviateException { + private final String cursor; + private final int pageSize; + + public static PaginationException after(String cursor, int pageSize, Throwable cause) { + return new PaginationException(cursor, pageSize, cause); + } + + private PaginationException(String cursor, int pageSize, Throwable cause) { + super("fetch next page, page_size=%d cursor=%s".formatted(pageSize, cursor), cause); + this.cursor = cursor; + this.pageSize = pageSize; + } + + /** A null-cursor means the error happened while fetching the first page. */ + public String cursor() { + return cursor; + } + + public int pageSize() { + return pageSize; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/pagination/Paginator.java b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/Paginator.java new file mode 100644 index 000000000..8ad18fd67 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/pagination/Paginator.java @@ -0,0 +1,145 @@ +package io.weaviate.client6.v1.api.collections.pagination; + +import java.util.Iterator; +import java.util.List; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.function.Function; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.query.FetchObjects; +import io.weaviate.client6.v1.api.collections.query.Filter; +import io.weaviate.client6.v1.api.collections.query.Metadata; +import io.weaviate.client6.v1.api.collections.query.QueryReference; +import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClient; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public class Paginator implements Iterable> { + static final int DEFAULT_PAGE_SIZE = 100; + + private final WeaviateQueryClient query; + private final Function> queryOptions; + private final int pageSize; + private final String cursor; + + @Override + public Iterator> iterator() { + return Spliterators.iterator(spliterator()); + } + + public Stream> stream() { + return StreamSupport.stream(spliterator(), false); + } + + public Spliterator> spliterator() { + return new CursorSpliterator(cursor, pageSize, + (after, limit) -> { + var fn = ObjectBuilder.partial(queryOptions, q -> q.after(after).limit(limit)); + try { + return query.fetchObjects(fn).objects(); + } catch (Exception e) { + throw PaginationException.after(cursor, pageSize, e); + } + }); + } + + public static Paginator of(WeaviateQueryClient query) { + return of(query, ObjectBuilder.identity()); + } + + public static Paginator of(WeaviateQueryClient query, + Function, ObjectBuilder>> fn) { + return fn.apply(new Builder<>(query)).build(); + } + + Paginator(Builder builder) { + this.query = builder.query; + this.queryOptions = builder.queryOptions; + this.cursor = builder.cursor; + this.pageSize = builder.pageSize; + } + + public static class Builder implements ObjectBuilder> { + private final WeaviateQueryClient query; + + private Function> queryOptions = ObjectBuilder.identity(); + private int pageSize = DEFAULT_PAGE_SIZE; + private String cursor; + + public Builder(WeaviateQueryClient query) { + this.query = query; + } + + // Pagination options ----------------------------------------------------- + + /** Set a different page size. Defaults to 100. */ + public Builder pageSize(int pageSize) { + this.pageSize = pageSize; + return this; + } + + /** Set a cursor (object UUID) to start pagination from. */ + public Builder fromCursor(String uuid) { + this.cursor = uuid; + return this; + } + + // Query options ---------------------------------------------------------- + + /** Combine several conditions using with an AND operator. */ + public final Builder filters(Filter... filters) { + return applyQueryOption(q -> q.filters(filters)); + } + + /** Include default vector. */ + public final Builder includeVector() { + return applyQueryOption(q -> q.includeVector()); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(String... vectors) { + return applyQueryOption(q -> q.includeVector(vectors)); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(List vectors) { + return applyQueryOption(q -> q.includeVector(vectors)); + } + + public final Builder returnProperties(String... properties) { + return applyQueryOption(q -> q.returnProperties(properties)); + } + + public final Builder returnProperties(List properties) { + return applyQueryOption(q -> q.returnProperties(properties)); + } + + public final Builder returnReferences(QueryReference... references) { + return applyQueryOption(q -> q.returnReferences(references)); + } + + public final Builder returnReferences(List references) { + return applyQueryOption(q -> q.returnReferences(references)); + } + + public final Builder returnMetadata(Metadata... metadata) { + return applyQueryOption(q -> q.returnMetadata(metadata)); + } + + public final Builder returnMetadata(List metadata) { + return applyQueryOption(q -> q.returnMetadata(metadata)); + } + + private final Builder applyQueryOption(Function> options) { + this.queryOptions = ObjectBuilder.partial(this.queryOptions, options); + return this; + } + + @Override + public Paginator build() { + return new Paginator<>(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/BQ.java b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/BQ.java new file mode 100644 index 000000000..9d4cdb691 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/BQ.java @@ -0,0 +1,62 @@ +package io.weaviate.client6.v1.api.collections.quantizers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record BQ( + @SerializedName("enabled") boolean enabled, + @SerializedName("rescore_limit") Integer rescoreLimit, + @SerializedName("cache") Boolean cache) implements Quantization { + + @Override + public Quantization.Kind _kind() { + return Quantization.Kind.BQ; + } + + @Override + public Object _self() { + return this; + } + + public static BQ of() { + return of(ObjectBuilder.identity()); + } + + public static BQ of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public BQ(Builder builder) { + this(builder.enabled, builder.rescoreLimit, builder.cache); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer rescoreLimit; + private Boolean cache; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder rescoreLimit(int rescoreLimit) { + this.rescoreLimit = rescoreLimit; + return this; + } + + public Builder cache(boolean enabled) { + this.cache = enabled; + return this; + } + + @Override + public BQ build() { + return new BQ(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/PQ.java b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/PQ.java new file mode 100644 index 000000000..a4806c12b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/PQ.java @@ -0,0 +1,111 @@ +package io.weaviate.client6.v1.api.collections.quantizers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record PQ( + @SerializedName("enabled") boolean enabled, + @SerializedName("centroids") Integer centroids, + @SerializedName("segments") Integer segments, + @SerializedName("encoder_type") EncoderType encoderType, + @SerializedName("encoder_distribution") EncoderDistribution encoderDistribution, + @SerializedName("training_limit") Integer trainingLimit, + @SerializedName("bit_compression") Boolean bitCompression) implements Quantization { + + public enum EncoderType { + @SerializedName("kmeans") + KMEANS, + @SerializedName("tile") + TILE; + } + + public enum EncoderDistribution { + @SerializedName("normal") + NORMAL, + @SerializedName("log-normal") + LOG_NORMAL; + } + + @Override + public Quantization.Kind _kind() { + return Quantization.Kind.PQ; + } + + @Override + public Object _self() { + return this; + } + + public static PQ of() { + return of(ObjectBuilder.identity()); + } + + public static PQ of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public PQ(Builder builder) { + this( + builder.enabled, + builder.centroids, + builder.segments, + builder.encoderType, + builder.encoderDistribution, + builder.trainingLimit, + builder.bitCompression); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer centroids; + private Integer segments; + private EncoderType encoderType; + private EncoderDistribution encoderDistribution; + private Integer trainingLimit; + private Boolean bitCompression; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder centroids(int centroids) { + this.centroids = centroids; + return this; + } + + public Builder segments(int segments) { + this.segments = segments; + return this; + } + + public Builder encoderType(EncoderType encoderType) { + this.encoderType = encoderType; + return this; + } + + public Builder encoderDistribution(EncoderDistribution encoderDistribution) { + this.encoderDistribution = encoderDistribution; + return this; + } + + public Builder trainingLimit(int trainingLimit) { + this.trainingLimit = trainingLimit; + return this; + } + + public Builder bitCompression(boolean enabled) { + this.bitCompression = enabled; + return this; + } + + @Override + public PQ build() { + return new PQ(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/RQ.java b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/RQ.java new file mode 100644 index 000000000..43dbfb2e0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/RQ.java @@ -0,0 +1,69 @@ +package io.weaviate.client6.v1.api.collections.quantizers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record RQ( + @SerializedName("enabled") boolean enabled, + @SerializedName("rescore_limit") Integer rescoreLimit, + @SerializedName("bits") Integer bits, + @SerializedName("cache") Boolean cache) implements Quantization { + + @Override + public Quantization.Kind _kind() { + return Quantization.Kind.RQ; + } + + @Override + public Object _self() { + return this; + } + + public static RQ of() { + return of(ObjectBuilder.identity()); + } + + public static RQ of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public RQ(Builder builder) { + this(builder.enabled, builder.rescoreLimit, builder.bits, builder.cache); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer rescoreLimit; + private Integer bits; + private Boolean cache; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder rescoreLimit(int rescoreLimit) { + this.rescoreLimit = rescoreLimit; + return this; + } + + public Builder bits(int bits) { + this.bits = bits; + return this; + } + + public Builder cache(boolean enabled) { + this.cache = enabled; + return this; + } + + @Override + public RQ build() { + return new RQ(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/SQ.java b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/SQ.java new file mode 100644 index 000000000..ccd9f7070 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/SQ.java @@ -0,0 +1,69 @@ +package io.weaviate.client6.v1.api.collections.quantizers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record SQ( + @SerializedName("enabled") boolean enabled, + @SerializedName("rescore_limit") Integer rescoreLimit, + @SerializedName("training_limit") Integer trainingLimit, + @SerializedName("cache") Boolean cache) implements Quantization { + + @Override + public Quantization.Kind _kind() { + return Quantization.Kind.SQ; + } + + @Override + public Object _self() { + return this; + } + + public static SQ of() { + return of(ObjectBuilder.identity()); + } + + public static SQ of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public SQ(Builder builder) { + this(builder.enabled, builder.rescoreLimit, builder.trainingLimit, builder.cache); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Integer rescoreLimit; + private Integer trainingLimit; + private Boolean cache; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder rescoreLimit(int rescoreLimit) { + this.rescoreLimit = rescoreLimit; + return this; + } + + public Builder trainingLimit(int trainingLimit) { + this.trainingLimit = trainingLimit; + return this; + } + + public Builder cache(boolean enabled) { + this.cache = enabled; + return this; + } + + @Override + public SQ build() { + return new SQ(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/Uncompressed.java b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/Uncompressed.java new file mode 100644 index 000000000..ad84ed7c9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/quantizers/Uncompressed.java @@ -0,0 +1,20 @@ +package io.weaviate.client6.v1.api.collections.quantizers; + +import io.weaviate.client6.v1.api.collections.Quantization; + +public record Uncompressed() implements Quantization { + + @Override + public Quantization.Kind _kind() { + return Quantization.Kind.UNCOMPRESSED; + } + + @Override + public Object _self() { + return true; + } + + public static Uncompressed of() { + return new Uncompressed(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java new file mode 100644 index 000000000..468643ece --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java @@ -0,0 +1,1732 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +abstract class AbstractQueryClient { + protected final CollectionDescriptor collection; + protected final GrpcTransport grpcTransport; + protected final CollectionHandleDefaults defaults; + + AbstractQueryClient(CollectionDescriptor collection, GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + this.collection = collection; + this.grpcTransport = grpcTransport; + this.defaults = defaults; + } + + /** Copy constructor that sets new defaults. */ + AbstractQueryClient( + AbstractQueryClient c, + CollectionHandleDefaults defaults) { + this(c.collection, c.grpcTransport, defaults); + } + + protected abstract SingleT fetchObjectById(FetchObjectById byId); + + protected abstract ResponseT performRequest(QueryOperator operator); + + protected abstract GroupedResponseT performRequest(QueryOperator operator, GroupBy groupBy); + + // Fetch by ID -------------------------------------------------------------- + + /** + * Retrieve the object by its UUID. + * + * @param uuid Object UUID. + * + * @return A collection object or empty {@link Optional}. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public SingleT fetchObjectById(String uuid) { + return fetchObjectById(FetchObjectById.of(uuid)); + } + + /** + * Retrieve the object by its UUID. + * + * @param uuid Object UUID. + * @param fn Lambda expression for optional parameters. + * @return A collection object or empty {@link Optional}. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public SingleT fetchObjectById(String uuid, Function> fn) { + // Collection handle defaults (consistencyLevel / tenant) are irrelevant for + // by-ID lookup. Do not `applyDefaults` to `fn`. + return fetchObjectById(FetchObjectById.of(uuid, fn)); + } + + /** + * Retrieve the first result from query response if any. + * + * @param response Query response. + * @return An object from the list or empty {@link Optional}. + */ + protected final

Optional> optionalFirst(QueryResponse

response) { + return response == null || response.objects().isEmpty() + ? Optional.empty() + : Optional.ofNullable(response.objects().get(0)); + + } + + // Object queries ----------------------------------------------------------- + + /** + * Retrieve objects in ascending UUID order. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT fetchObjects() { + return fetchObjects(FetchObjects.of()); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter. + * + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT fetchObjects(Function> fn) { + return fetchObjects(FetchObjects.of(fn)); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter. + * + * @param query FetchObjects query. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT fetchObjects(FetchObjects query) { + return performRequest(query); + } + + /** + * Retrieve objects in ascending UUID order. + * + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT fetchObjects(GroupBy groupBy) { + return fetchObjects(FetchObjects.of(), groupBy); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter. + * + * + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT fetchObjects(Function> fn, + GroupBy groupBy) { + return fetchObjects(FetchObjects.of(fn), groupBy); + } + + /** + * Retrieve objects without applying a Vector Search or Keyword Search filter. + * + * @param query FetchObjects query. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT fetchObjects(FetchObjects query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // BM25 queries ------------------------------------------------------------- + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query Query string. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25(String query) { + return bm25(Bm25.of(query)); + } + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query Query string. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25(String query, Function> fn) { + return bm25(Bm25.of(query, fn)); + } + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query BM25 query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT bm25(Bm25 query) { + return performRequest(query); + } + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query Query string. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT bm25(String query, GroupBy groupBy) { + return bm25(Bm25.of(query), groupBy); + } + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query Query string. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT bm25(String query, Function> fn, GroupBy groupBy) { + return bm25(Bm25.of(query, fn), groupBy); + } + + /** + * Query collection objects using keyword (BM25) search. + * + * @param query BM25 query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT bm25(Bm25 query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // Hybrid queries ----------------------------------------------------------- + + /** + * Query collection objects using hybrid search. + * + * @param query Query string. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(String query) { + return hybrid(Hybrid.of(query)); + } + + /** + * Query collection objects using hybrid search. + * + * @param query Query string. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(String query, Function> fn) { + return hybrid(Hybrid.of(query, fn)); + } + + /** + * Query collection objects using hybrid search. + * + * @param searchTarget Query target. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(Target searchTarget) { + return hybrid(Hybrid.of(searchTarget)); + } + + /** + * Query collection objects using hybrid search. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(Target searchTarget, Function> fn) { + return hybrid(Hybrid.of(searchTarget, fn)); + } + + /** + * Query collection objects using hybrid search. + * + * @param query Hybrid query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT hybrid(Hybrid query) { + return performRequest(query); + } + + /** + * Query collection objects using hybrid search. + * + * @param query Query string. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT hybrid(String query, GroupBy groupBy) { + return hybrid(Hybrid.of(query), groupBy); + } + + /** + * Query collection objects using hybrid search. + * + * @param query Query string. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT hybrid(String query, Function> fn, GroupBy groupBy) { + return hybrid(Hybrid.of(query, fn), groupBy); + } + + /** + * Query collection objects using hybrid search. + * + * @param searchTarget Query target. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT hybrid(Target searchTarget, GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget), groupBy); + } + + /** + * Query collection objects using hybrid search. + * + * @param searchTarget Query target. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT hybrid(Target searchTarget, Function> fn, + GroupBy groupBy) { + return hybrid(Hybrid.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using hybrid search. + * + * @param query Query string. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT hybrid(Hybrid query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearVector queries ------------------------------------------------------- + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[] vector) { + return nearVector(Target.vector(vector)); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[] vector, Function> fn) { + return nearVector(Target.vector(vector), fn); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[][] vector) { + return nearVector(Target.vector(vector)); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(float[][] vector, Function> fn) { + return nearVector(Target.vector(vector), fn); + } + + /** + * Query collection objects using near vector search. + * + * @param searchTarget Target query vectors. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVectorTarget searchTarget) { + return nearVector(NearVector.of(searchTarget)); + } + + /** + * Query collection objects using near vector search. + * + * @param searchTarget Target query vectors. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVectorTarget searchTarget, + Function> fn) { + return nearVector(NearVector.of(searchTarget, fn)); + } + + /** + * Query collection objects using near vector search. + * + * @param query Near vector query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVector(NearVector query) { + return performRequest(query); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, GroupBy groupBy) { + return nearVector(Target.vector(vector), groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(float[] vector, Function> fn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), fn, groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, GroupBy groupBy) { + return nearVector(Target.vector(vector), groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param vector Query vector. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(float[][] vector, Function> fn, + GroupBy groupBy) { + return nearVector(Target.vector(vector), fn, groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param searchTarget Target query vectors. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(NearVectorTarget searchTarget, + GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param searchTarget Target query vectors. + * @param fn Lambda expression for optional parameters. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(NearVectorTarget searchTarget, + Function> fn, + GroupBy groupBy) { + return nearVector(NearVector.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near vector search. + * + * @param query Near vector query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVector(NearVector query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearObject queries ------------------------------------------------------- + + /** + * Query collection objects using near object search. + * + * @param uuid Query object UUID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(String uuid) { + return nearObject(NearObject.of(uuid)); + } + + /** + * Query collection objects using near object search. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(String uuid, Function> fn) { + return nearObject(NearObject.of(uuid, fn)); + } + + /** + * Query collection objects using near object search. + * + * @param query Near object query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearObject(NearObject query) { + return performRequest(query); + } + + /** + * Query collection objects using near object search. + * + * @param uuid Query object UUID. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, GroupBy groupBy) { + return nearObject(NearObject.of(uuid), groupBy); + } + + /** + * Query collection objects using near object search. + * + * @param uuid Query object UUID. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearObject(String uuid, Function> fn, + GroupBy groupBy) { + return nearObject(NearObject.of(uuid, fn), groupBy); + } + + /** + * Query collection objects using near object search. + * + * @param query Near object query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearObject(NearObject query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearText queries --------------------------------------------------------- + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(String... text) { + return nearText(Target.text(Arrays.asList(text))); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(String text, Function> fn) { + return nearText(Target.text(List.of(text)), fn); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(List text, Function> fn) { + return nearText(Target.text(text), fn); + } + + /** + * Query collection objects using near text search. + * + * @param searchTarget Target query concepts. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(Target searchTarget) { + return nearText(NearText.of(searchTarget)); + } + + /** + * Query collection objects using near text search. + * + * @param searchTarget Target query concepts. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(Target searchTarget, Function> fn) { + return nearText(NearText.of(searchTarget, fn)); + } + + /** + * Query collection objects using near text search. + * + * @param query Near text query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearText(NearText query) { + return performRequest(query); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(String text, GroupBy groupBy) { + return nearText(Target.text(List.of(text)), groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(List text, GroupBy groupBy) { + return nearText(Target.text(text), groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(String text, + Function> fn, + GroupBy groupBy) { + return nearText(Target.text(List.of(text)), fn, groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param text Query concepts. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(List text, + Function> fn, + GroupBy groupBy) { + return nearText(Target.text(text), fn, groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param searchTarget Target query concepts. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, GroupBy groupBy) { + return nearText(NearText.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param searchTarget Target query concepts. + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(Target searchTarget, + Function> fn, + GroupBy groupBy) { + return nearText(NearText.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near text search. + * + * @param query Near text query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearText(NearText query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearImage queries -------------------------------------------------------- + + /** + * Query collection objects using near image search. + * + * @param image Query image (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(String image) { + return nearImage(NearImage.of(image)); + } + + /** + * Query collection objects using near image search. + * + * @param image Query image (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(String image, Function> fn) { + return nearImage(NearImage.of(image, fn)); + } + + /** + * Query collection objects using near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(Target searchTarget) { + return nearImage(NearImage.of(searchTarget)); + } + + /** + * Query collection objects using near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(Target searchTarget, Function> fn) { + return nearImage(NearImage.of(searchTarget, fn)); + } + + /** + * Query collection objects using near image search. + * + * @param query Near image query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImage(NearImage query) { + return performRequest(query); + } + + /** + * Query collection objects using near image search. + * + * @param image Query image (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see QueryResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImage(String image, GroupBy groupBy) { + return nearImage(NearImage.of(image), groupBy); + } + + /** + * Query collection objects using near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImage(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near image search. + * + * @param searchTarget Query target (base64-encoded image). + * @param groupBy Group-by clause. + * @return Grouped query result. + * + * @see GroupBy + * @see QueryResponseGrouped + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public GroupedResponseT nearImage(Target searchTarget, GroupBy groupBy) { + return nearImage(NearImage.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near image search. + * + * @param image Query image (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImage(String image, Function> fn, + GroupBy groupBy) { + return nearImage(NearImage.of(image, fn), groupBy); + } + + /** + * Query collection objects using near image search. + * + * @param query Near image query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImage(NearImage query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearAudio queries -------------------------------------------------------- + + /** + * Query collection objects using near audio search. + * + * @param audio Query audio (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(String audio) { + return nearAudio(NearAudio.of(audio)); + } + + /** + * Query collection objects using near audio search. + * + * @param audio Query audio (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(String audio, Function> fn) { + return nearAudio(NearAudio.of(audio, fn)); + } + + /** + * Query collection objects using near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(Target searchTarget) { + return nearAudio(NearAudio.of(searchTarget)); + } + + /** + * Query collection objects using near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(Target searchTarget, Function> fn) { + return nearAudio(NearAudio.of(searchTarget, fn)); + } + + /** + * Query collection objects using near audio search. + * + * @param query Near audio query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearAudio(NearAudio query) { + return performRequest(query); + } + + /** + * Query collection objects using near audio search. + * + * @param audio Query audio (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearAudio(String audio, GroupBy groupBy) { + return nearAudio(NearAudio.of(audio), groupBy); + } + + /** + * Query collection objects using near audio search. + * + * @param audio Query audio (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + + public GroupedResponseT nearAudio(String audio, Function> fn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(audio, fn), groupBy); + } + + /** + * Query collection objects using near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearAudio(Target searchTarget, GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near audio search. + * + * @param searchTarget Query target (base64-encoded audio). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + + public GroupedResponseT nearAudio(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearAudio(NearAudio.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near audio search. + * + * @param query Near audio query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearAudio(NearAudio query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearVideo queries -------------------------------------------------------- + + /** + * Query collection objects using near video search. + * + * @param video Query video (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(String video) { + return nearVideo(NearVideo.of(video)); + } + + /** + * Query collection objects using near video search. + * + * @param video Query video (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(String video, Function> fn) { + return nearVideo(NearVideo.of(video, fn)); + } + + /** + * Query collection objects using near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(Target searchTarget) { + return nearVideo(NearVideo.of(searchTarget)); + } + + /** + * Query collection objects using near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(Target searchTarget, Function> fn) { + return nearVideo(NearVideo.of(searchTarget, fn)); + } + + /** + * Query collection objects using near video search. + * + * @param query Near video query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearVideo(NearVideo query) { + return performRequest(query); + } + + /** + * Query collection objects using near video search. + * + * @param video Query video (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVideo(String video, GroupBy groupBy) { + return nearVideo(NearVideo.of(video), groupBy); + } + + /** + * Query collection objects using near video search. + * + * @param video Query video (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVideo(String video, Function> fn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(video, fn), groupBy); + } + + /** + * Query collection objects using near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVideo(Target searchTarget, GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near video search. + * + * @param searchTarget Query target (base64-encoded video). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVideo(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearVideo(NearVideo.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near video search. + * + * @param query Near video query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearVideo(NearVideo query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearThermal queries ------------------------------------------------------ + + /** + * Query collection objects using near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(String thermal) { + return nearThermal(NearThermal.of(thermal)); + } + + /** + * Query collection objects using near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(String thermal, Function> fn) { + return nearThermal(NearThermal.of(thermal, fn)); + } + + /** + * Query collection objects using near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal data). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(Target searchTarget) { + return nearThermal(NearThermal.of(searchTarget)); + } + + /** + * Query collection objects using near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal data). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(Target searchTarget, Function> fn) { + return nearThermal(NearThermal.of(searchTarget, fn)); + } + + /** + * Query collection objects using near thermal search. + * + * @param query Near thermal query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearThermal(NearThermal query) { + return performRequest(query); + } + + /** + * Query collection objects using near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearThermal(String thermal, GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal), groupBy); + } + + /** + * Query collection objects using near thermal search. + * + * @param thermal Query thermal (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearThermal(String thermal, Function> fn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(thermal, fn), groupBy); + } + + /** + * Query collection objects using near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal data). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearThermal(Target searchTarget, GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near thermal search. + * + * @param searchTarget Query target (base64-encoded thermal data). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearThermal(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearThermal(NearThermal.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near thermal search. + * + * @param query Near thermal query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearThermal(NearThermal query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearDepth queries -------------------------------------------------------- + + /** + * Query collection objects using near depth search. + * + * @param depth Query depth (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(String depth) { + return nearDepth(NearDepth.of(depth)); + } + + /** + * Query collection objects using near depth search. + * + * @param depth Query depth (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(String depth, Function> fn) { + return nearDepth(NearDepth.of(depth, fn)); + } + + /** + * Query collection objects using near depth search. + * + * @param searchTarget Query target (base64-encoded depth data). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(Target searchTarget) { + return nearDepth(NearDepth.of(searchTarget)); + } + + /** + * Query collection objects using near depth search. + * + * @param searchTarget Query target (base64-encoded depth data). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(Target searchTarget, Function> fn) { + return nearDepth(NearDepth.of(searchTarget, fn)); + } + + /** + * Query collection objects using near depth search. + * + * @param query Near depth query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearDepth(NearDepth query) { + return performRequest(query); + } + + /** + * Query collection objects using near depth search. + * + * @param depth Query depth (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearDepth(String depth, GroupBy groupBy) { + return nearDepth(NearDepth.of(depth), groupBy); + } + + /** + * Query collection objects using near depth search. + * + * @param depth Query depth (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearDepth(String depth, Function> fn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(depth, fn), groupBy); + } + + /** + * Query collection objects using near depth search. + * + * @param searchTarget Query target (base64-encoded depth data). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearDepth(Target searchTarget, GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near depth search. + * + * @param searchTarget Query target (base64-encoded depth data). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearDepth(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearDepth(NearDepth.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near depth search. + * + * @param query Near depth query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearDepth(NearDepth query, GroupBy groupBy) { + return performRequest(query, groupBy); + } + + // NearImu queries ---------------------------------------------------------- + + /** + * Query collection objects using near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(String imu) { + return nearImu(NearImu.of(imu)); + } + + /** + * Query collection objects using near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(String imu, Function> fn) { + return nearImu(NearImu.of(imu, fn)); + } + + /** + * Query collection objects using near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU data). + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(Target searchTarget) { + return nearImu(NearImu.of(searchTarget)); + } + + /** + * Query collection objects using near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU data). + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(Target searchTarget, Function> fn) { + return nearImu(NearImu.of(searchTarget, fn)); + } + + /** + * Query collection objects using near IMU search. + * + * @param query Near IMU query request. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public ResponseT nearImu(NearImu query) { + return performRequest(query); + } + + /** + * Query collection objects using near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImu(String imu, GroupBy groupBy) { + return nearImu(NearImu.of(imu), groupBy); + } + + /** + * Query collection objects using near IMU search. + * + * @param imu Query IMU (base64-encoded). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImu(String imu, Function> fn, + GroupBy groupBy) { + return nearImu(NearImu.of(imu, fn), groupBy); + } + + /** + * Query collection objects using near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU data). + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImu(Target searchTarget, GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget), groupBy); + } + + /** + * Query collection objects using near IMU search. + * + * @param searchTarget Query target (base64-encoded IMU data). + * @param fn Lambda expression for optional parameters. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImu(Target searchTarget, Function> fn, + GroupBy groupBy) { + return nearImu(NearImu.of(searchTarget, fn), groupBy); + } + + /** + * Query collection objects using near IMU search. + * + * @param query Near IMU query request. + * @param groupBy Group-by clause. + * @return Grouped query result. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * + * @see GroupBy + * @see QueryResponseGrouped + */ + public GroupedResponseT nearImu(NearImu query, GroupBy groupBy) { + return performRequest(query, groupBy); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseQueryOptions.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseQueryOptions.java new file mode 100644 index 000000000..f16f27544 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseQueryOptions.java @@ -0,0 +1,263 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import org.apache.commons.lang3.StringUtils; + +import io.weaviate.client6.v1.api.collections.query.Metadata.MetadataField; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record BaseQueryOptions( + Integer limit, + Integer offset, + Integer autolimit, + String after, + ConsistencyLevel consistencyLevel, + Filter filters, + GenerativeSearch generativeSearch, + List returnProperties, + List returnReferences, + List returnMetadata, + List includeVectors) { + + public static final String ID_PROPERTY = "_id"; + public static final String CREATION_TIME_PROPERTY = "_creationTimeUnix"; + public static final String LAST_UPDATE_TIME_PROPERTY = "_lastUpdateTimeUnix"; + + private BaseQueryOptions(Builder, T> builder) { + this( + builder.limit, + builder.offset, + builder.autolimit, + builder.after, + builder.consistencyLevel, + builder.filter, + builder.generativeSearch, + builder.returnProperties, + builder.returnReferences, + builder.returnMetadata, + builder.includeVectors); + + } + + @SuppressWarnings("unchecked") + public static abstract class Builder, T extends Object> implements ObjectBuilder { + private Integer limit; + private Integer offset; + private Integer autolimit; + private String after; + private ConsistencyLevel consistencyLevel; + private Filter filter; + private GenerativeSearch generativeSearch; + private List returnProperties = new ArrayList<>(); + private List returnReferences = new ArrayList<>(); + private List returnMetadata = new ArrayList<>(); + private List includeVectors = new ArrayList<>(); + + protected Builder() { + returnMetadata(MetadataField.UUID); + } + + /** + * Limit the number of returned objects. + * + *

+ * Combine with {@link #offset(int)} to use offset-based pagination. + */ + public final SelfT limit(int limit) { + this.limit = limit; + return (SelfT) this; + } + + /** + * Skip the first N objects in the result set. + * + *

+ * Combine with {@link #limit(int)} to use offset-based pagination. + */ + public final SelfT offset(int offset) { + this.offset = offset; + return (SelfT) this; + } + + /** + * Discard results after an automatically calculated cutoff point. + * + * @param autolimit The number of "groups" to keep. + * @see Documentation + */ + public final SelfT autolimit(int autolimit) { + this.autolimit = autolimit; + return (SelfT) this; + } + + /** + * Discard results before this object. + * + * @param after UUID of an object in this collection. + */ + public final SelfT after(String after) { + this.after = after; + return (SelfT) this; + } + + /** Set consitency level for query resolution. */ + public final SelfT consistencyLevel(ConsistencyLevel consistencyLevel) { + this.consistencyLevel = consistencyLevel; + return (SelfT) this; + } + + /** + * Add arguments for generative query. + * Builders which support this parameter should make the method public. + * + * @param fn Lambda expression for optional parameters. + */ + protected SelfT generate(Function> fn) { + this.generativeSearch = GenerativeSearch.of(fn); + return (SelfT) this; + } + + /** + * Filter result set using traditional filtering operators: {@code eq}, + * {@code gte}, {@code like}, etc. + * Subsequent calls to {@link #filter} aggregate with an AND operator. + */ + public final SelfT filters(Filter filter) { + this.filter = this.filter == null + ? filter + : Filter.and(this.filter, filter); + return (SelfT) this; + } + + /** Combine several conditions using with an AND operator. */ + public final SelfT filters(Filter... filters) { + Arrays.stream(filters).map(this::filters); + return (SelfT) this; + } + + /** Select properties to include in the query result. */ + public final SelfT returnProperties(String... properties) { + return returnProperties(Arrays.asList(properties)); + } + + /** Select properties to include in the query result. */ + public final SelfT returnProperties(List properties) { + this.returnProperties.addAll(properties); + return (SelfT) this; + } + + /** Select cross-referenced objects to include in the query result. */ + public final SelfT returnReferences(QueryReference... references) { + return returnReferences(Arrays.asList(references)); + } + + /** Select cross-referenced objects to include in the query result. */ + public final SelfT returnReferences(List references) { + this.returnReferences.addAll(references); + return (SelfT) this; + } + + /** Select metadata to include in the query result. */ + public final SelfT returnMetadata(Metadata... metadata) { + return returnMetadata(Arrays.asList(metadata)); + } + + /** Select metadata to include in the query result. */ + public final SelfT returnMetadata(List metadata) { + this.returnMetadata.addAll(metadata); + return (SelfT) this; + } + + /** Include default vector. */ + public final SelfT includeVector() { + return returnMetadata(MetadataField.VECTOR); + } + + /** Include one or more named vectors in the metadata response. */ + public final SelfT includeVector(String... vectors) { + return includeVector(Arrays.asList(vectors)); + } + + /** Include one or more named vectors in the metadata response. */ + public final SelfT includeVector(List vectors) { + this.includeVectors.addAll(vectors); + return (SelfT) this; + } + + final BaseQueryOptions baseOptions() { + return _build(); + } + + @Override + public T build() { + return (T) _build(); + } + + private BaseQueryOptions _build() { + return new BaseQueryOptions(this); + } + } + + final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + if (limit != null) { + req.setLimit(limit); + } + if (offset != null) { + req.setOffset(offset); + } + if (StringUtils.isNotBlank(after)) { + req.setAfter(after); + } + if (autolimit != null) { + req.setAutocut(autolimit); + } + + if (consistencyLevel != null) { + consistencyLevel.appendTo(req); + } + + if (filters != null) { + var filter = WeaviateProtoBase.Filters.newBuilder(); + filters.appendTo(filter); + req.setFilters(filter); + } + + if (generativeSearch != null) { + var generative = WeaviateProtoGenerative.GenerativeSearch.newBuilder(); + generativeSearch.appendTo(generative); + req.setGenerative(generative); + } + + var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder(); + returnMetadata.forEach(m -> m.appendTo(metadata)); + metadata.addAllVectors(includeVectors); + req.setMetadata(metadata); + + if (!returnProperties.isEmpty() || !returnReferences.isEmpty()) { + var properties = WeaviateProtoSearchGet.PropertiesRequest.newBuilder(); + + if (returnProperties.isEmpty()) { + properties.setReturnAllNonrefProperties(true); + } else { + properties.addAllNonRefProperties(returnProperties); + } + + if (!returnReferences.isEmpty()) { + returnReferences.forEach(r -> { + var ref = WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder(); + r.appendTo(ref); + properties.addRefProperties(ref); + }); + } + req.setProperties(properties); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseVectorSearchBuilder.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseVectorSearchBuilder.java new file mode 100644 index 000000000..31e4c4075 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/BaseVectorSearchBuilder.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.api.collections.query; + +abstract class BaseVectorSearchBuilder, NearT extends Object> + extends BaseQueryOptions.Builder { + + // Optional query parameters. + Float distance; + Float certainty; + Rerank rerank; + + /** + * Discard objects whose vectors are further away + * from the target vector than the threshold. + * + *

+ * Use {@link Hybrid.Builder#maxVectorDistance(float)} if {@link NearVector} or + * {@link NearText} are used as a vector search component in hybrid search. + */ + @SuppressWarnings("unchecked") + public SelfT distance(float distance) { + this.distance = distance; + return (SelfT) this; + } + + /** + * Discard objects whose vectors are further away + * from the target vector than the threshold according + * to a normalized ({@code 0 <= c <= 0}) distance. + * + *

+ * Certainty is only meaningful for {@code cosine} distance. + * Prefer using {@link #distance(float)} to limit search results. + */ + @SuppressWarnings("unchecked") + public SelfT certainty(float certainty) { + this.certainty = certainty; + return (SelfT) this; + } + + /** + * Control the ranking of the query results. + */ + @SuppressWarnings("unchecked") + public SelfT rerank(Rerank rerank) { + this.rerank = rerank; + return (SelfT) this; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Bm25.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Bm25.java new file mode 100644 index 000000000..899487a62 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Bm25.java @@ -0,0 +1,81 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record Bm25( + String query, + List queryProperties, + SearchOperator searchOperator, + BaseQueryOptions common) implements QueryOperator { + + public static final Bm25 of(String query) { + return of(query, ObjectBuilder.identity()); + } + + public static final Bm25 of(String query, Function> fn) { + return fn.apply(new Builder(query)).build(); + } + + public Bm25(Builder builder) { + this(builder.query, builder.queryProperties, builder.searchOperator, builder.baseOptions()); + } + + public static class Builder extends BaseQueryOptions.Builder { + // Required query parameters. + private final String query; + + // Optional query parameters. + List queryProperties = new ArrayList<>(); + SearchOperator searchOperator; + + public Builder(String query) { + this.query = query; + } + + /** Select properties to be included in the results scoring. */ + public Builder queryProperties(String... properties) { + return queryProperties(Arrays.asList(properties)); + } + + /** Select properties to be included in the results scoring. */ + public Builder queryProperties(List properties) { + this.queryProperties.addAll(properties); + return this; + } + + /** + * Select BM25 + * Search Operator to use. + */ + public Builder searchOperator(SearchOperator searchOperator) { + this.searchOperator = searchOperator; + return this; + } + + @Override + public final Bm25 build() { + return new Bm25(this); + } + } + + @Override + public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + var bm25 = WeaviateProtoBaseSearch.BM25.newBuilder() + .setQuery(query) + .addAllProperties(queryProperties); + + if (searchOperator != null) { + searchOperator.appendTo(bm25); + } + req.setBm25Search(bm25); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java new file mode 100644 index 000000000..326609d2e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java @@ -0,0 +1,50 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public enum ConsistencyLevel { + /** + * The operation succeeds as soon as one replica acknowledges the request. This + * is the fastest and most available, but least consistent option. + */ + ONE(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "ONE"), + /** + * The operation succeeds when a majority of replicas (calculated as + * replication_factor/2 + 1) respond. This provides a balance between + * consistency and availability. + */ + QUORUM(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "QUORUM"), + /** + * The operation succeeds only when all replicas respond. This is the most + * consistent but least available and slowest option. + */ + ALL(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "ALL"); + + private final WeaviateProtoBase.ConsistencyLevel consistencyLevel; + private final String queryParameter; + + ConsistencyLevel(WeaviateProtoBase.ConsistencyLevel consistencyLevel, String queryParameter) { + this.consistencyLevel = consistencyLevel; + this.queryParameter = queryParameter; + } + + public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + req.setConsistencyLevel(consistencyLevel); + } + + public final void appendTo(WeaviateProtoBatchDelete.BatchDeleteRequest.Builder req) { + req.setConsistencyLevel(consistencyLevel); + } + + public final void appendTo(WeaviateProtoBatch.BatchObjectsRequest.Builder req) { + req.setConsistencyLevel(consistencyLevel); + } + + @Override + public String toString() { + return queryParameter; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjectById.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjectById.java new file mode 100644 index 000000000..3e3bdf512 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjectById.java @@ -0,0 +1,138 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.query.Metadata.MetadataField; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record FetchObjectById( + String uuid, + List returnProperties, + List returnReferences, + List returnMetadata, + List includeVectors) implements QueryOperator { + + public static FetchObjectById of(String uuid) { + return of(uuid, ObjectBuilder.identity()); + } + + public static FetchObjectById of(String uuid, Function> fn) { + return fn.apply(new Builder(uuid)).build(); + } + + public FetchObjectById(Builder builder) { + this(builder.uuid, + new ArrayList<>(builder.returnProperties), + builder.returnReferences, + new ArrayList<>(builder.returnMetadata), + builder.includeVectors); + } + + public static class Builder implements ObjectBuilder { + // Required query parameters. + private final String uuid; + + private Set returnProperties = new HashSet<>(); + private List returnReferences = new ArrayList<>(); + private Set returnMetadata = new HashSet<>(); + private List includeVectors = new ArrayList<>(); + + public Builder(String uuid) { + this.uuid = uuid; + returnMetadata(MetadataField.UUID); + } + + /** Select properties to include in the query result. */ + public final Builder returnProperties(String... properties) { + return returnProperties(Arrays.asList(properties)); + } + + /** Select properties to include in the query result. */ + public final Builder returnProperties(List properties) { + this.returnProperties.addAll(properties); + return this; + } + + /** Select cross-referenced objects to include in the query result. */ + public final Builder returnReferences(QueryReference... references) { + return returnReferences(Arrays.asList(references)); + } + + /** Select cross-referenced objects to include in the query result. */ + public final Builder returnReferences(List references) { + this.returnReferences.addAll(references); + return this; + } + + /** Select metadata to include in the query result. */ + public final Builder returnMetadata(Metadata... metadata) { + return returnMetadata(Arrays.asList(metadata)); + } + + /** Select metadata to include in the query result. */ + public final Builder returnMetadata(List metadata) { + this.returnMetadata.addAll(metadata); + return this; + } + + /** Include default vector. */ + public final Builder includeVector() { + return returnMetadata(MetadataField.VECTOR); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(String... vectors) { + return includeVector(Arrays.asList(vectors)); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(List vectors) { + this.includeVectors.addAll(vectors); + return this; + } + + @Override + public FetchObjectById build() { + return new FetchObjectById(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + var filters = Filter.uuid().eq(uuid); + var filter = WeaviateProtoBase.Filters.newBuilder(); + filters.appendTo(filter); + req.setFilters(filter); + + var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder(); + returnMetadata.forEach(m -> m.appendTo(metadata)); + metadata.addAllVectors(includeVectors); + req.setMetadata(metadata); + + if (!returnProperties.isEmpty() || !returnReferences.isEmpty()) { + var properties = WeaviateProtoSearchGet.PropertiesRequest.newBuilder(); + + if (returnProperties.isEmpty()) { + properties.setReturnAllNonrefProperties(true); + } else { + properties.addAllNonRefProperties(returnProperties); + } + + if (!returnReferences.isEmpty()) { + returnReferences.forEach(r -> { + var ref = WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder(); + r.appendTo(ref); + properties.addRefProperties(ref); + }); + } + req.setProperties(properties); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjects.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjects.java new file mode 100644 index 000000000..ae2147a94 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/FetchObjects.java @@ -0,0 +1,73 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record FetchObjects(BaseQueryOptions common, List sortBy) implements QueryOperator { + + public static FetchObjects of() { + return of(ObjectBuilder.identity()); + } + + public static FetchObjects of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public FetchObjects(Builder builder) { + this(builder.baseOptions(), builder.sortBy); + } + + public static class Builder extends BaseQueryOptions.Builder { + private final List sortBy = new ArrayList<>(); + + /** + * Sort query results. Default sorted order is ascending, use + * {@link SortBy#desc} to reverse it. + * + *

{@code
+     * sort(SortBy.property("age"), SortBy.creationTime().desc());
+     * }
+ * + * @param sortBy A list of sort-by clauses in the order + * they should be applied. + * @return This builder. + */ + public Builder sort(SortBy... sortBy) { + return sort(Arrays.asList(sortBy)); + } + + /** + * Sort query results. Default sorted order is ascending, use + * {@link SortBy#desc} to reverse it. + * + * @param sortBy A list of sort-by clauses in the order + * they should be applied. + * @return This builder. + */ + public Builder sort(List sortBy) { + this.sortBy.addAll(sortBy); + return this; + } + + @Override + public final FetchObjects build() { + return new FetchObjects(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + + for (final var sort : sortBy) { + req.addSortBy(WeaviateProtoSearchGet.SortBy.newBuilder() + .addAllPath(sort.path()) + .setAscending(sort.ascending())); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Filter.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Filter.java new file mode 100644 index 000000000..6a2dc38a0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Filter.java @@ -0,0 +1,969 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.time.OffsetDateTime; +import java.util.Arrays; +import java.util.List; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters; + +public class Filter implements FilterOperand { + + private enum Operator { + // Logical operators + AND("And", WeaviateProtoBase.Filters.Operator.OPERATOR_AND), + OR("Or", WeaviateProtoBase.Filters.Operator.OPERATOR_OR), + NOT("Noe", WeaviateProtoBase.Filters.Operator.OPERATOR_NOT), + + // Comparison operators + EQUAL("Equal", WeaviateProtoBase.Filters.Operator.OPERATOR_EQUAL), + NOT_EQUAL("NotEqual", WeaviateProtoBase.Filters.Operator.OPERATOR_NOT_EQUAL), + LESS_THAN("LessThan", WeaviateProtoBase.Filters.Operator.OPERATOR_LESS_THAN), + LESS_THAN_EQUAL("LessThenEqual", WeaviateProtoBase.Filters.Operator.OPERATOR_LESS_THAN_EQUAL), + GREATER_THAN("GreaterThan", WeaviateProtoBase.Filters.Operator.OPERATOR_GREATER_THAN), + GREATER_THAN_EQUAL("GreaterThanEqual", WeaviateProtoBase.Filters.Operator.OPERATOR_GREATER_THAN_EQUAL), + IS_NULL("IsNull", WeaviateProtoBase.Filters.Operator.OPERATOR_IS_NULL), + LIKE("Like", WeaviateProtoBase.Filters.Operator.OPERATOR_LIKE), + CONTAINS_ANY("ContainsAny", WeaviateProtoBase.Filters.Operator.OPERATOR_CONTAINS_ANY), + CONTAINS_ALL("ContainsAll", WeaviateProtoBase.Filters.Operator.OPERATOR_CONTAINS_ALL), + CONTAINS_NONE("ContainsNone", WeaviateProtoBase.Filters.Operator.OPERATOR_CONTAINS_NONE), + WITHIN_GEO_RANGE("WithinGeoRange", WeaviateProtoBase.Filters.Operator.OPERATOR_WITHIN_GEO_RANGE); + + /** String representation for better debug logs. */ + private final String stringValue; + + /** gRPC operator value . */ + private final WeaviateProtoBase.Filters.Operator grpcValue; + + private Operator(String stringValue, WeaviateProtoBase.Filters.Operator grpcValue) { + this.stringValue = stringValue; + this.grpcValue = grpcValue; + } + + public void appendTo(Filters.Builder filter) { + filter.setOperator(grpcValue); + } + + @Override + public String toString() { + return stringValue; + } + } + + private final Operator operator; + private final List operands; + + @SafeVarargs + private Filter(Operator operator, FilterOperand... operands) { + this(operator, Arrays.asList(operands)); + } + + private Filter(Operator operator, List operands) { + this.operator = operator; + this.operands = operands; + } + + @Override + public boolean isEmpty() { + // Guard against Filter.and(Filter.or(), Filter.and(), Filter.not()) situation. + return operands.isEmpty() + || operands.stream().allMatch(operator -> operator == null | operator.isEmpty()); + } + + @Override + public String toString() { + if (operator == Operator.NOT) { + return "%s %s".formatted(operator, operands.get(0)); + } + var operandStrings = operands.stream().map(Object::toString).toList(); + return "Filter(" + String.join(" " + operator.toString() + " ", operandStrings) + ")"; + } + + // Logical operators return a complete operand. + // -------------------------------------------------------------------------- + public static Filter and(final FilterOperand... operands) { + return new Filter(Operator.AND, operands); + } + + public static Filter and(final List operands) { + return new Filter(Operator.AND, operands); + } + + public static Filter or(final FilterOperand... operands) { + return new Filter(Operator.OR, operands); + } + + public static Filter or(final List operands) { + return new Filter(Operator.OR, operands); + } + + public static Filter not(final FilterOperand operand) { + return new Filter(Operator.NOT, operand); + } + + /** Negate this expression. */ + public Filter not() { + return not(this); + } + + // Comparison operators return fluid builder. + // -------------------------------------------------------------------------- + + /** Filter by object UUID. */ + public static UuidProperty uuid() { + return new UuidProperty(); + } + + /** Filter by object creation time. */ + public static DateProperty createdAt() { + return new DateProperty(BaseQueryOptions.CREATION_TIME_PROPERTY); + } + + /** Filter by object last update time. */ + public static DateProperty lastUpdatedAt() { + return new DateProperty(BaseQueryOptions.LAST_UPDATE_TIME_PROPERTY); + } + + /** Filter by object property. */ + public static FilterBuilder property(String property) { + return new FilterBuilder(new PathOperand(false, property)); + } + + /** Filter by object property's length. */ + public static FilterBuilder propertyLen(String property) { + return new FilterBuilder(new PathOperand(true, property)); + } + + public static class FilterBuilder { + private final FilterOperand left; + + private FilterBuilder(FilterOperand left) { + this.left = left; + } + + // Equal + // ------------------------------------------------------------------------ + public Filter eq(String value) { + return new Filter(Operator.EQUAL, left, new TextOperand(value)); + } + + public Filter eq(String... values) { + return new Filter(Operator.EQUAL, left, new TextArrayOperand(values)); + } + + public Filter eq(boolean value) { + return new Filter(Operator.EQUAL, left, new BooleanOperand(value)); + } + + public Filter eq(Boolean... values) { + return new Filter(Operator.EQUAL, left, new BooleanArrayOperand(values)); + } + + public Filter eq(long value) { + return new Filter(Operator.EQUAL, left, new IntegerOperand(value)); + } + + public Filter eq(int value) { + return new Filter(Operator.EQUAL, left, new IntegerOperand(value)); + } + + public Filter eq(Long... values) { + return new Filter(Operator.EQUAL, left, new IntegerArrayOperand(values)); + } + + public Filter eq(double value) { + return new Filter(Operator.EQUAL, left, new NumberOperand(value)); + } + + public Filter eq(float value) { + return new Filter(Operator.EQUAL, left, new NumberOperand(value)); + } + + public Filter eq(Double... values) { + return new Filter(Operator.EQUAL, left, new NumberArrayOperand(values)); + } + + public Filter eq(OffsetDateTime value) { + return new Filter(Operator.EQUAL, left, new DateOperand(value)); + } + + public Filter eq(OffsetDateTime... values) { + return new Filter(Operator.EQUAL, left, new DateArrayOperand(values)); + } + + public Filter eq(Object value) { + return new Filter(Operator.EQUAL, left, fromObject(value)); + } + + // NotEqual + // ------------------------------------------------------------------------ + public Filter ne(String value) { + return new Filter(Operator.NOT_EQUAL, left, new TextOperand(value)); + } + + public Filter ne(String... values) { + return new Filter(Operator.NOT_EQUAL, left, new TextArrayOperand(values)); + } + + public Filter ne(boolean value) { + return new Filter(Operator.NOT_EQUAL, left, new BooleanOperand(value)); + } + + public Filter ne(Boolean... values) { + return new Filter(Operator.NOT_EQUAL, left, new BooleanArrayOperand(values)); + } + + public Filter ne(long value) { + return new Filter(Operator.NOT_EQUAL, left, new IntegerOperand(value)); + } + + public Filter ne(int value) { + return new Filter(Operator.NOT_EQUAL, left, new IntegerOperand(value)); + } + + public Filter ne(Long... values) { + return new Filter(Operator.NOT_EQUAL, left, new IntegerArrayOperand(values)); + } + + public Filter ne(double value) { + return new Filter(Operator.NOT_EQUAL, left, new NumberOperand(value)); + } + + public Filter ne(float value) { + return new Filter(Operator.NOT_EQUAL, left, new NumberOperand(value)); + } + + public Filter ne(Double... values) { + return new Filter(Operator.NOT_EQUAL, left, new NumberArrayOperand(values)); + } + + public Filter ne(OffsetDateTime value) { + return new Filter(Operator.NOT_EQUAL, left, new DateOperand(value)); + } + + public Filter ne(OffsetDateTime... values) { + return new Filter(Operator.NOT_EQUAL, left, new DateArrayOperand(values)); + } + + public Filter ne(Object value) { + return new Filter(Operator.NOT_EQUAL, left, fromObject(value)); + } + + // LessThan + // ------------------------------------------------------------------------ + public Filter lt(String value) { + return new Filter(Operator.LESS_THAN, left, new TextOperand(value)); + } + + public Filter lt(String... values) { + return new Filter(Operator.LESS_THAN, left, new TextArrayOperand(values)); + } + + public Filter lt(long value) { + return new Filter(Operator.LESS_THAN, left, new IntegerOperand(value)); + } + + public Filter lt(int value) { + return new Filter(Operator.LESS_THAN, left, new IntegerOperand(value)); + } + + public Filter lt(Long... values) { + return new Filter(Operator.LESS_THAN, left, new IntegerArrayOperand(values)); + } + + public Filter lt(double value) { + return new Filter(Operator.LESS_THAN, left, new NumberOperand(value)); + } + + public Filter lt(float value) { + return new Filter(Operator.LESS_THAN, left, new NumberOperand(value)); + } + + public Filter lt(Double... values) { + return new Filter(Operator.LESS_THAN, left, new NumberArrayOperand(values)); + } + + public Filter lt(OffsetDateTime value) { + return new Filter(Operator.LESS_THAN, left, new DateOperand(value)); + } + + public Filter lt(OffsetDateTime... values) { + return new Filter(Operator.LESS_THAN, left, new DateArrayOperand(values)); + } + + public Filter lt(Object value) { + return new Filter(Operator.LESS_THAN, left, fromObject(value)); + } + + // LessThanEqual + // ------------------------------------------------------------------------ + public Filter lte(String value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new TextOperand(value)); + } + + public Filter lte(String... values) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new TextArrayOperand(values)); + } + + public Filter lte(long value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new IntegerOperand(value)); + } + + public Filter lte(int value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new IntegerOperand(value)); + } + + public Filter lte(Long... values) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new IntegerArrayOperand(values)); + } + + public Filter lte(double value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new NumberOperand(value)); + } + + public Filter lte(float value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new NumberOperand(value)); + } + + public Filter lte(Double... values) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new NumberArrayOperand(values)); + } + + public Filter lte(OffsetDateTime value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new DateOperand(value)); + } + + public Filter lte(OffsetDateTime... values) { + return new Filter(Operator.LESS_THAN_EQUAL, left, new DateArrayOperand(values)); + } + + public Filter lte(Object value) { + return new Filter(Operator.LESS_THAN_EQUAL, left, fromObject(value)); + } + + // GreaterThan + // ------------------------------------------------------------------------ + public Filter gt(String value) { + return new Filter(Operator.GREATER_THAN, left, new TextOperand(value)); + } + + public Filter gt(String... values) { + return new Filter(Operator.GREATER_THAN, left, new TextArrayOperand(values)); + } + + public Filter gt(long value) { + return new Filter(Operator.GREATER_THAN, left, new IntegerOperand(value)); + } + + public Filter gt(int value) { + return new Filter(Operator.GREATER_THAN, left, new IntegerOperand(value)); + } + + public Filter gt(Long... values) { + return new Filter(Operator.GREATER_THAN, left, new IntegerArrayOperand(values)); + } + + public Filter gt(double value) { + return new Filter(Operator.GREATER_THAN, left, new NumberOperand(value)); + } + + public Filter gt(float value) { + return new Filter(Operator.GREATER_THAN, left, new NumberOperand(value)); + } + + public Filter gt(Double... values) { + return new Filter(Operator.GREATER_THAN, left, new NumberArrayOperand(values)); + } + + public Filter gt(OffsetDateTime value) { + return new Filter(Operator.GREATER_THAN, left, new DateOperand(value)); + } + + public Filter gt(OffsetDateTime... values) { + return new Filter(Operator.GREATER_THAN, left, new DateArrayOperand(values)); + } + + public Filter gt(Object value) { + return new Filter(Operator.GREATER_THAN, left, fromObject(value)); + } + + // GreaterThanEqual + // ------------------------------------------------------------------------ + public Filter gte(String value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new TextOperand(value)); + } + + public Filter gte(String... values) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new TextArrayOperand(values)); + } + + public Filter gte(long value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new IntegerOperand(value)); + } + + public Filter gte(int value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new IntegerOperand(value)); + } + + public Filter gte(Long... values) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new IntegerArrayOperand(values)); + } + + public Filter gte(double value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new NumberOperand(value)); + } + + public Filter gte(float value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new NumberOperand(value)); + } + + public Filter gte(Double... values) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new NumberArrayOperand(values)); + } + + public Filter gte(OffsetDateTime value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new DateOperand(value)); + } + + public Filter gte(OffsetDateTime... values) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, new DateArrayOperand(values)); + } + + public Filter gte(Object value) { + return new Filter(Operator.GREATER_THAN_EQUAL, left, fromObject(value)); + } + + // IsNull + // ------------------------------------------------------------------------ + public Filter isNull() { + return isNull(true); + } + + public Filter isNotNull() { + return isNull(false); + } + + public Filter isNull(boolean isNull) { + return new Filter(Operator.IS_NULL, left, new BooleanOperand(isNull)); + } + + // Like + // ------------------------------------------------------------------------ + public Filter like(String value) { + return new Filter(Operator.LIKE, left, new TextOperand(value)); + } + + // ContainsAny + // ------------------------------------------------------------------------ + public Filter containsAny(String value) { + return new Filter(Operator.CONTAINS_ANY, left, new TextOperand(value)); + } + + public Filter containsAny(String... values) { + return new Filter(Operator.CONTAINS_ANY, left, new TextArrayOperand(values)); + } + + public Filter containsAny(List values) { + return new Filter(Operator.CONTAINS_ANY, left, new TextArrayOperand(values)); + } + + public Filter containsAny(Boolean... values) { + return new Filter(Operator.CONTAINS_ANY, left, new BooleanArrayOperand(values)); + } + + public Filter containsAny(Long... values) { + return new Filter(Operator.CONTAINS_ANY, left, new IntegerArrayOperand(values)); + } + + public Filter containsAny(Double... values) { + return new Filter(Operator.CONTAINS_ANY, left, new NumberArrayOperand(values)); + } + + public Filter containsAny(OffsetDateTime... values) { + return new Filter(Operator.CONTAINS_ANY, left, new DateArrayOperand(values)); + } + + // ContainsAll + // ------------------------------------------------------------------------ + public Filter containsAll(String value) { + return new Filter(Operator.CONTAINS_ALL, left, new TextOperand(value)); + } + + public Filter containsAll(String... values) { + return new Filter(Operator.CONTAINS_ALL, left, new TextArrayOperand(values)); + } + + public Filter containsAll(List values) { + return new Filter(Operator.CONTAINS_ALL, left, new TextArrayOperand(values)); + } + + public Filter containsAll(Boolean... values) { + return new Filter(Operator.CONTAINS_ALL, left, new BooleanArrayOperand(values)); + } + + public Filter containsAll(Long... values) { + return new Filter(Operator.CONTAINS_ALL, left, new IntegerArrayOperand(values)); + } + + public Filter containsAll(Double... values) { + return new Filter(Operator.CONTAINS_ALL, left, new NumberArrayOperand(values)); + } + + public Filter containsAll(OffsetDateTime... values) { + return new Filter(Operator.CONTAINS_ALL, left, new DateArrayOperand(values)); + } + + // ContainsNone + // ------------------------------------------------------------------------ + public Filter containsNone(String value) { + return new Filter(Operator.CONTAINS_NONE, left, new TextOperand(value)); + } + + public Filter containsNone(String... values) { + return new Filter(Operator.CONTAINS_NONE, left, new TextArrayOperand(values)); + } + + public Filter containsNone(List values) { + return new Filter(Operator.CONTAINS_NONE, left, new TextArrayOperand(values)); + } + + public Filter containsNone(Boolean... values) { + return new Filter(Operator.CONTAINS_NONE, left, new BooleanArrayOperand(values)); + } + + public Filter containsNone(Long... values) { + return new Filter(Operator.CONTAINS_NONE, left, new IntegerArrayOperand(values)); + } + + public Filter containsNone(Double... values) { + return new Filter(Operator.CONTAINS_NONE, left, new NumberArrayOperand(values)); + } + + public Filter containsNone(OffsetDateTime... values) { + return new Filter(Operator.CONTAINS_NONE, left, new DateArrayOperand(values)); + } + + // WithinGeoRange + // ------------------------------------------------------------------------ + public Filter withinGeoRange(float lat, float lon, float maxDistance) { + return new Filter(Operator.WITHIN_GEO_RANGE, left, new GeoRangeOperand(lat, lon, maxDistance)); + } + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + if (isEmpty()) { + return; + } + + operator.appendTo(filter); + + if (operator == Operator.AND || operator == Operator.OR || operator == Operator.NOT) { + operands.forEach(op -> { + var nested = Filters.newBuilder(); + op.appendTo(nested); + filter.addFilters(nested); + }); + } else { + // Comparison operators: eq, gt, lt, like, etc. + operands.forEach(op -> op.appendTo(filter)); + } + } + + @SuppressWarnings("unchecked") + static FilterOperand fromObject(Object value) { + if (value instanceof String str) { + return new TextOperand(str); + } else if (value instanceof Boolean bool) { + return new BooleanOperand(bool); + } else if (value instanceof Long l) { + return new IntegerOperand(l); + } else if (value instanceof Integer i) { + return new IntegerOperand(i); + } else if (value instanceof Double dbl) { + return new NumberOperand(dbl); + } else if (value instanceof Float f) { + return new NumberOperand(f); + } else if (value instanceof OffsetDateTime date) { + return new DateOperand(date); + } else if (value instanceof String[] strarr) { + return new TextArrayOperand(strarr); + } else if (value instanceof Boolean[] boolarr) { + return new BooleanArrayOperand(boolarr); + } else if (value instanceof Long[] lngarr) { + return new IntegerArrayOperand(lngarr); + } else if (value instanceof Double[] dblarr) { + return new NumberArrayOperand(dblarr); + } else if (value instanceof OffsetDateTime[] datearr) { + return new DateArrayOperand(datearr); + } else if (value instanceof List list) { + if (list.isEmpty()) { + throw new IllegalArgumentException( + "Filter with non-reifiable type (List) cannot be empty, use an array instead"); + } + + Object first = list.get(0); + if (first instanceof String) { + return new TextArrayOperand((List) value); + } else if (first instanceof Boolean) { + return new BooleanArrayOperand((List) value); + } else if (first instanceof Long) { + return new IntegerArrayOperand((List) value); + } else if (first instanceof Double) { + return new NumberArrayOperand((List) value); + } else if (first instanceof OffsetDateTime) { + return new DateArrayOperand((List) value); + } + } + throw new IllegalArgumentException( + "value must be either of String, Boolean, OffsetDateTime, Long, Double, or Array/List of these types"); + } + + private static class PathOperand implements FilterOperand { + private final List path; + private final boolean length; + + private PathOperand(boolean length, List path) { + this.path = path; + this.length = length; + } + + private PathOperand(boolean length, String... path) { + this(length, Arrays.asList(path)); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + if (!path.isEmpty()) { + var property = path.get(0); + if (length) { + property = "len(" + property + ")"; + } + filter.setTarget(WeaviateProtoBase.FilterTarget.newBuilder() + .setProperty(property)); + } + // FIXME: no way to reference objects rn? + } + + @Override + public String toString() { + return String.join("::", path); + } + } + + public static class UuidProperty extends PathOperand { + private UuidProperty() { + super(false, BaseQueryOptions.ID_PROPERTY); + } + + public Filter eq(String value) { + return new Filter(Operator.EQUAL, this, new TextOperand(value)); + } + + public Filter ne(String value) { + return new Filter(Operator.NOT_EQUAL, this, new TextOperand(value)); + } + + public Filter gt(String value) { + return new Filter(Operator.GREATER_THAN, this, new TextOperand(value)); + } + + public Filter gte(String value) { + return new Filter(Operator.GREATER_THAN_EQUAL, this, new TextOperand(value)); + } + + public Filter lt(String value) { + return new Filter(Operator.LESS_THAN, this, new TextOperand(value)); + } + + public Filter lte(String value) { + return new Filter(Operator.LESS_THAN_EQUAL, this, new TextOperand(value)); + } + + public Filter containsAny(String... values) { + return new Filter(Operator.CONTAINS_ANY, this, new TextArrayOperand(values)); + } + + public Filter containsNone(String... values) { + return new Filter(Operator.CONTAINS_NONE, this, new TextArrayOperand(values)); + } + } + + public static class DateProperty extends PathOperand { + private DateProperty(String propertyName) { + super(false, propertyName); + } + + public Filter eq(OffsetDateTime value) { + return new Filter(Operator.EQUAL, this, new DateOperand(value)); + } + + public Filter ne(OffsetDateTime value) { + return new Filter(Operator.NOT_EQUAL, this, new DateOperand(value)); + } + + public Filter gt(OffsetDateTime value) { + return new Filter(Operator.GREATER_THAN, this, new DateOperand(value)); + } + + public Filter gte(OffsetDateTime value) { + return new Filter(Operator.GREATER_THAN_EQUAL, this, new DateOperand(value)); + } + + public Filter lt(OffsetDateTime value) { + return new Filter(Operator.LESS_THAN, this, new DateOperand(value)); + } + + public Filter lte(OffsetDateTime value) { + return new Filter(Operator.LESS_THAN_EQUAL, this, new DateOperand(value)); + } + + public Filter containsAny(OffsetDateTime... values) { + return new Filter(Operator.CONTAINS_ANY, this, new DateArrayOperand(values)); + } + + public Filter containsNone(OffsetDateTime... values) { + return new Filter(Operator.CONTAINS_NONE, this, new DateArrayOperand(values)); + } + } + + private static class TextOperand implements FilterOperand { + private final String value; + + private TextOperand(String value) { + this.value = value; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueText(value); + } + + @Override + public String toString() { + return value; + } + } + + private static class TextArrayOperand implements FilterOperand { + private final List values; + + private TextArrayOperand(List values) { + this.values = values; + } + + @SafeVarargs + private TextArrayOperand(String... values) { + this(Arrays.asList(values)); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueTextArray(WeaviateProtoBase.TextArray.newBuilder().addAllValues(values)); + } + + @Override + public String toString() { + return values.toString(); + } + } + + private static class BooleanOperand implements FilterOperand { + private final boolean value; + + private BooleanOperand(boolean value) { + this.value = value; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueBoolean(value); + } + + @Override + public String toString() { + return Boolean.toString(value); + } + } + + private static class BooleanArrayOperand implements FilterOperand { + private final List values; + + private BooleanArrayOperand(List values) { + this.values = values; + } + + @SafeVarargs + private BooleanArrayOperand(Boolean... values) { + this(Arrays.asList(values)); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueBooleanArray(WeaviateProtoBase.BooleanArray.newBuilder().addAllValues(values)); + } + + @Override + public String toString() { + return values.toString(); + } + } + + private static class IntegerOperand implements FilterOperand { + private final long value; + + private IntegerOperand(long value) { + this.value = value; + } + + private IntegerOperand(int value) { + this.value = value; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueInt(value); + } + + @Override + public String toString() { + return Long.toString(value); + } + } + + private static class IntegerArrayOperand implements FilterOperand { + private final List values; + + private IntegerArrayOperand(List values) { + this.values = values; + } + + @SafeVarargs + private IntegerArrayOperand(Long... values) { + this(Arrays.asList(values)); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueIntArray(WeaviateProtoBase.IntArray.newBuilder().addAllValues(values)); + } + + @Override + public String toString() { + return values.toString(); + } + } + + private static class NumberOperand implements FilterOperand { + private final double value; + + private NumberOperand(double value) { + this.value = value; + } + + private NumberOperand(float value) { + this.value = value; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueNumber(value); + } + + @Override + public String toString() { + return Double.toString(value); + } + } + + private static class NumberArrayOperand implements FilterOperand { + private final List values; + + private NumberArrayOperand(List values) { + this.values = values; + } + + @SafeVarargs + private NumberArrayOperand(Double... values) { + this(Arrays.asList(values)); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueNumberArray(WeaviateProtoBase.NumberArray.newBuilder().addAllValues(values)); + } + + @Override + public String toString() { + return values.toString(); + } + } + + private static class DateOperand implements FilterOperand { + private final OffsetDateTime value; + + private DateOperand(OffsetDateTime value) { + this.value = value; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueText(value.toString()); + } + + @Override + public String toString() { + return value.toString(); + } + } + + private static class DateArrayOperand implements FilterOperand { + private final List values; + + private DateArrayOperand(List values) { + this.values = values; + } + + @SafeVarargs + private DateArrayOperand(OffsetDateTime... values) { + this(Arrays.asList(values)); + } + + private List formatted() { + return values.stream().map(OffsetDateTime::toString).toList(); + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueTextArray(WeaviateProtoBase.TextArray.newBuilder().addAllValues(formatted())); + } + + @Override + public String toString() { + return values.toString(); + } + } + + private static class GeoRangeOperand implements FilterOperand { + private final float lat; + private final float lon; + private final float distance; + + private GeoRangeOperand(float lat, float lon, float distance) { + this.lat = lat; + this.lon = lon; + this.distance = distance; + } + + @Override + public void appendTo(WeaviateProtoBase.Filters.Builder filter) { + filter.setValueGeo(WeaviateProtoBase.GeoCoordinatesFilter.newBuilder() + .setLatitude(lat).setLongitude(lon).setDistance(distance)); + } + + @Override + public String toString() { + return "(lat=%d, lon=%d, distance=%d)".formatted(lat, lon, distance); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/FilterOperand.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/FilterOperand.java new file mode 100644 index 000000000..b7a79683b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/FilterOperand.java @@ -0,0 +1,11 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; + +public interface FilterOperand { + void appendTo(WeaviateProtoBase.Filters.Builder filter); + + default boolean isEmpty() { + return false; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/GenerativeSearch.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/GenerativeSearch.java new file mode 100644 index 000000000..359dd282c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/GenerativeSearch.java @@ -0,0 +1,157 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative; + +public record GenerativeSearch(Single single, Grouped grouped) { + public static GenerativeSearch of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public GenerativeSearch(Builder builder) { + this(builder.single, builder.grouped); + } + + public static class Builder implements ObjectBuilder { + private Single single; + private Grouped grouped; + + public Builder singlePrompt(String prompt) { + this.single = Single.of(prompt); + return this; + } + + public Builder singlePrompt(String prompt, Function> fn) { + this.single = Single.of(prompt, fn); + return this; + + } + + public Builder groupedTask(String prompt) { + this.grouped = Grouped.of(prompt); + return this; + } + + public Builder groupedTask(String prompt, Function> fn) { + this.grouped = Grouped.of(prompt, fn); + return this; + } + + @Override + public GenerativeSearch build() { + return new GenerativeSearch(this); + } + } + + void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + if (single != null) { + single.appendTo(req); + } + if (grouped != null) { + grouped.appendTo(req); + } + } + + public record Single(String prompt, boolean debug) { + public static Single of(String prompt) { + return of(prompt, ObjectBuilder.identity()); + } + + public static Single of(String prompt, Function> fn) { + return fn.apply(new Builder(prompt)).build(); + } + + public Single(Builder builder) { + this(builder.prompt, builder.debug); + } + + public static class Builder implements ObjectBuilder { + private final String prompt; + private boolean debug = false; + + public Builder(String prompt) { + this.prompt = prompt; + } + + public Builder debug(boolean enable) { + this.debug = enable; + return this; + } + + @Override + public Single build() { + return new Single(this); + } + } + + public void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + req.setSingle( + WeaviateProtoGenerative.GenerativeSearch.Single.newBuilder() + .setPrompt(prompt) + .setDebug(debug)); + } + } + + public record Grouped(String prompt, boolean debug, List properties) { + public static Grouped of(String prompt) { + return of(prompt, ObjectBuilder.identity()); + } + + public static Grouped of(String prompt, Function> fn) { + return fn.apply(new Builder(prompt)).build(); + } + + public Grouped(Builder builder) { + this(builder.prompt, builder.debug, builder.properties); + } + + public static class Builder implements ObjectBuilder { + private final String prompt; + private final List properties = new ArrayList<>(); + private boolean debug = false; + + public Builder(String prompt) { + this.prompt = prompt; + } + + public Builder properties(String... properties) { + return properties(Arrays.asList(properties)); + } + + public Builder properties(List properties) { + this.properties.addAll(properties); + return this; + } + + public Builder debug(boolean enable) { + this.debug = enable; + return this; + } + + @Override + public Grouped build() { + return new Grouped(this); + } + } + + public void appendTo(WeaviateProtoGenerative.GenerativeSearch.Builder req) { + var grouped = WeaviateProtoGenerative.GenerativeSearch.Grouped.newBuilder() + .setTask(prompt) + .setDebug(debug); + + if (properties != null && !properties.isEmpty()) { + grouped.setProperties( + WeaviateProtoBase.TextArray.newBuilder() + .addAllValues(properties)); + + } + req.setGrouped(grouped); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/GroupBy.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/GroupBy.java new file mode 100644 index 000000000..2cb430ffd --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/GroupBy.java @@ -0,0 +1,25 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.List; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record GroupBy(List path, int maxGroups, int maxObjectsPerGroup) { + /** + * Group results by the property value. + * + * @param property Property name. + * @param maxGroups Maximum number of groups to return. + * @param maxObjectsPerGroup Maximum number of objects to include in a group. + */ + public static GroupBy property(String property, int maxGroups, int maxObjectsPerGroup) { + return new GroupBy(List.of(property), maxGroups, maxObjectsPerGroup); + } + + void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + req.setGroupBy(WeaviateProtoSearchGet.GroupBy.newBuilder() + .addAllPath(path) + .setNumberOfGroups(maxGroups) + .setObjectsPerGroup(maxObjectsPerGroup)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Hybrid.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Hybrid.java new file mode 100644 index 000000000..6f284c5a5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Hybrid.java @@ -0,0 +1,208 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record Hybrid( + Target searchTarget, + List queryProperties, + SearchOperator searchOperator, + Float alpha, + QueryOperator near, + FusionType fusionType, + Float maxVectorDistance, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static enum FusionType { + RELATIVE_SCORE, RANKED; + } + + public static final Hybrid of(String query) { + return of(Target.text(List.of(query))); + } + + public static final Hybrid of(String query, Function> fn) { + return of(Target.text(List.of(query)), fn); + } + + public static final Hybrid of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static final Hybrid of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public Hybrid(Builder builder) { + this( + builder.searchTarget, + builder.queryProperties, + builder.searchOperator, + builder.alpha, + builder.near, + builder.fusionType, + builder.maxVectorDistance, + builder.baseOptions()); + } + + public static class Builder extends BaseQueryOptions.Builder { + // Required query parameters. + private final Target searchTarget; + + // Optional query parameters. + List queryProperties = new ArrayList<>(); + SearchOperator searchOperator; + Float alpha; + QueryOperator near; + FusionType fusionType; + Float maxVectorDistance; + + public Builder(Target searchTarget) { + this.searchTarget = searchTarget; + } + + /** Select properties to be included in the results scoring. */ + public Builder queryProperties(String... properties) { + return queryProperties(Arrays.asList(properties)); + } + + /** Select properties to be included in the results scoring. */ + public Builder queryProperties(List properties) { + this.queryProperties = properties; + return this; + } + + /** + * Select BM25 + * Search Operator to use. + */ + public Builder searchOperator(SearchOperator searchOperator) { + this.searchOperator = searchOperator; + return this; + } + + /** + * Apply custom weighting between vector search and keyword search components. + * + *
    + *
  • {@code alpha=1}: Pure BM25 search + *
  • {@code alpha=0}: Pure vector search + *
  • {@code alpha>0.5}: More weight to vector search + *
  • {@code alpha<0.5}: More weight to BM25 search + *
+ */ + public Builder alpha(float alpha) { + this.alpha = alpha; + return this; + } + + /** + * Select the fusion algorithm for combining + * vector search and keyword search results. + */ + public Builder fusionType(FusionType fusionType) { + this.fusionType = fusionType; + return this; + } + + /** Set the maximum allowable distance for the vector search component. */ + public Builder maxVectorDistance(float maxVectorDistance) { + this.maxVectorDistance = maxVectorDistance; + return this; + } + + /** + * Vector search component. + * + * @see NearVector#of + */ + public Builder nearVector(NearVector nearVector) { + this.near = nearVector; + return this; + } + + /** + * Vector search component. + * + * @see NearText#of + */ + public Builder nearText(NearText nearText) { + this.near = nearText; + return this; + } + + @Override + public final Hybrid build() { + return new Hybrid(this); + } + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setHybrid(protoBuilder()); + } + + @Override + public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setHybridSearch(protoBuilder()); + } + + private WeaviateProtoBaseSearch.Hybrid.Builder protoBuilder() { + var hybrid = WeaviateProtoBaseSearch.Hybrid.newBuilder() + .addAllProperties(queryProperties); + + if (searchTarget instanceof TextTarget text) { + hybrid.setQuery(text.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + hybrid.setQuery(combined.query().get(0)); + } + + if (alpha != null) { + hybrid.setAlpha(alpha); + } + + if (fusionType != null) { + switch (fusionType) { + case RANKED: + hybrid.setFusionType(WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_RANKED); + case RELATIVE_SCORE: + hybrid.setFusionType(WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_RELATIVE_SCORE); + } + } + + if (maxVectorDistance != null) { + hybrid.setVectorDistance(maxVectorDistance); + } + + if (near != null) { + if (near instanceof NearVector nv) { + hybrid.setNearVector(nv.protoBuilder(false)); + } else if (near instanceof NearText nt) { + hybrid.setNearText(nt.protoBuilder(false)); + } + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + hybrid.setTargets(targets); + } + + return hybrid; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Metadata.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Metadata.java new file mode 100644 index 000000000..0c9e7bd4e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Metadata.java @@ -0,0 +1,117 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.api.collections.vectorindex.Distance; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +/** + * Metadata is the common base for all properties that are requestes as + * "_additional". It is an inteface all metadata properties MUST implement to be + * used in {@link BaseQueryOptions}. + */ +public interface Metadata { + void appendTo(WeaviateProtoSearchGet.MetadataRequest.Builder metadata); + + /** Include metadata in the metadata response. */ + public static final Metadata ALL = MetadataField.ALL; + /** Include object creation time in the metadata response. */ + public static final Metadata CREATION_TIME_UNIX = MetadataField.CREATION_TIME_UNIX; + /** Include last update time in the metadata response. */ + public static final Metadata LAST_UPDATE_TIME_UNIX = MetadataField.LAST_UPDATE_TIME_UNIX; + /** + * Include raw distance determined as part of the vector search. + * The units will correspond to the distance metric configured for the vector + * index; by default {@link Distance#COSINE}. + * + *

+ * Distance is only applicable to vector search results, + * i.e. all {@code Near-} queries. Hybrid search will not return a distance, + * as the BM25-VectorSearch fusion algorithm transforms the distance metric. + * + * @see + * Distance metric in Hybrid search + */ + public static final Metadata DISTANCE = MetadataField.DISTANCE; + /** + * Include certainty in the metadata response. + * + *

+ * Certainty is an opinionated measure that always returns a number + * between 0 and 1. It is therefore usable with fixed-range distance metrics, + * such as {@code cosine}. + * + * @see + * Distance vs. Certainty + */ + public static final Metadata CERTAINTY = MetadataField.CERTAINTY; + /** + * Include {@code BM25F} score of the search result in the metadata response. + * + *

+ * {@link Metadata#SCORE} and {@link Metadata#EXPLAIN_SCORE} are only relevant + * for Hybrid and BM25 search. + */ + public static final Metadata SCORE = MetadataField.SCORE; + /** + * Include the result score broken down into components. + * The output is an unstructured string that is mostly useful for debugging + * search results. + * + *

+ * {@link Metadata#SCORE} and {@link Metadata#EXPLAIN_SCORE} are only relevant + * for Hybrid and BM25 search. + */ + public static final Metadata EXPLAIN_SCORE = MetadataField.EXPLAIN_SCORE; + + /** + * MetadataField are collection properties that can be requested for any object. + */ + enum MetadataField implements Metadata { + ALL, + UUID, + VECTOR, + CREATION_TIME_UNIX, + LAST_UPDATE_TIME_UNIX, + DISTANCE, + CERTAINTY, + SCORE, + EXPLAIN_SCORE; + + public void appendTo(WeaviateProtoSearchGet.MetadataRequest.Builder metadata) { + switch (this) { + case ALL: + for (final var f : MetadataField.values()) { + if (f != ALL) { + f.appendTo(metadata); + } + } + break; + case UUID: + metadata.setUuid(true); + break; + case VECTOR: + metadata.setVector(true); + break; + case CREATION_TIME_UNIX: + metadata.setCreationTimeUnix(true); + break; + case LAST_UPDATE_TIME_UNIX: + metadata.setLastUpdateTimeUnix(true); + break; + case DISTANCE: + metadata.setDistance(true); + break; + case CERTAINTY: + metadata.setCertainty(true); + break; + case EXPLAIN_SCORE: + metadata.setExplainScore(true); + break; + case SCORE: + metadata.setScore(true); + break; + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearAudio.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearAudio.java new file mode 100644 index 000000000..aa943849f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearAudio.java @@ -0,0 +1,87 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearAudio(Target searchTarget, Float distance, Float certainty, Rerank rerank, BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearAudio of(String audio) { + return of(Target.blob(audio)); + } + + public static NearAudio of(String audio, Function> fn) { + return of(Target.blob(audio), fn); + } + + public static NearAudio of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearAudio of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearAudio(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target audio) { + super(audio); + } + + @Override + public final NearAudio build() { + return new NearAudio(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearAudio(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearAudio(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearAudioSearch.Builder protoBuilder() { + var nearAudio = WeaviateProtoBaseSearch.NearAudioSearch.newBuilder(); + if (searchTarget instanceof TextTarget text) { + nearAudio.setAudio(text.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearAudio.setAudio(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearAudio.setTargets(targets); + } + + if (certainty != null) { + nearAudio.setCertainty(certainty); + } else if (distance != null) { + nearAudio.setDistance(distance); + } + + return nearAudio; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearDepth.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearDepth.java new file mode 100644 index 000000000..7405242dc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearDepth.java @@ -0,0 +1,91 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearDepth( + Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearDepth of(String depth) { + return of(Target.blob(depth)); + } + + public static NearDepth of(String depth, Function> fn) { + return of(Target.blob(depth), fn); + } + + public static NearDepth of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearDepth of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearDepth(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target searchTarget) { + super(searchTarget); + } + + @Override + public final NearDepth build() { + return new NearDepth(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearDepth(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearDepth(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearDepthSearch.Builder protoBuilder() { + var nearDepth = WeaviateProtoBaseSearch.NearDepthSearch.newBuilder(); + if (searchTarget instanceof TextTarget depth) { + nearDepth.setDepth(depth.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearDepth.setDepth(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearDepth.setTargets(targets); + } + + if (certainty != null) { + nearDepth.setCertainty(certainty); + } else if (distance != null) { + nearDepth.setDistance(distance); + } + return nearDepth; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImage.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImage.java new file mode 100644 index 000000000..960368807 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImage.java @@ -0,0 +1,91 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearImage( + Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearImage of(String image) { + return of(Target.blob(image)); + } + + public static NearImage of(String image, Function> fn) { + return of(Target.blob(image), fn); + } + + public static NearImage of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearImage of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearImage(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target searchTarget) { + super(searchTarget); + } + + @Override + public final NearImage build() { + return new NearImage(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearImage(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearImage(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearImageSearch.Builder protoBuilder() { + var nearImage = WeaviateProtoBaseSearch.NearImageSearch.newBuilder(); + if (searchTarget instanceof TextTarget image) { + nearImage.setImage(image.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearImage.setImage(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearImage.setTargets(targets); + } + + if (certainty != null) { + nearImage.setCertainty(certainty); + } else if (distance != null) { + nearImage.setDistance(distance); + } + return nearImage; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImu.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImu.java new file mode 100644 index 000000000..420fcde6e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearImu.java @@ -0,0 +1,91 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearImu( + Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearImu of(String imu) { + return of(Target.blob(imu)); + } + + public static NearImu of(String imu, Function> fn) { + return of(Target.blob(imu), fn); + } + + public static NearImu of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearImu of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearImu(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target searchTarget) { + super(searchTarget); + } + + @Override + public final NearImu build() { + return new NearImu(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearImu(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearImu(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearIMUSearch.Builder protoBuilder() { + var nearImu = WeaviateProtoBaseSearch.NearIMUSearch.newBuilder(); + if (searchTarget instanceof TextTarget imu) { + nearImu.setImu(imu.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearImu.setImu(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearImu.setTargets(targets); + } + + if (certainty != null) { + nearImu.setCertainty(certainty); + } else if (distance != null) { + nearImu.setDistance(distance); + } + return nearImu; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearMediaBuilder.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearMediaBuilder.java new file mode 100644 index 000000000..b9777aae0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearMediaBuilder.java @@ -0,0 +1,11 @@ +package io.weaviate.client6.v1.api.collections.query; + +abstract class NearMediaBuilder, MediaT extends Object> + extends BaseVectorSearchBuilder { + // Required query parameters. + final Target media; + + public NearMediaBuilder(Target media) { + this.media = media; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearObject.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearObject.java new file mode 100644 index 000000000..9f08e5243 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearObject.java @@ -0,0 +1,79 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearObject( + String uuid, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static final NearObject of(String uuid) { + return of(uuid, ObjectBuilder.identity()); + } + + public static final NearObject of(String uuid, Function> fn) { + return fn.apply(new Builder(uuid)).build(); + } + + public NearObject(Builder builder) { + this( + builder.uuid, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends BaseVectorSearchBuilder { + // Required query parameters. + private final String uuid; + + public Builder(String uuid) { + this.uuid = uuid; + } + + public Builder excludeSelf() { + return filters(Filter.uuid().ne(uuid)); + } + + @Override + public final NearObject build() { + return new NearObject(this); + } + } + + @Override + public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearObject(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearObject(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearObject.Builder protoBuilder() { + var nearObject = WeaviateProtoBaseSearch.NearObject.newBuilder() + .setId(uuid); + + if (certainty != null) { + nearObject.setCertainty(certainty); + } else if (distance != null) { + nearObject.setDistance(distance); + } + return nearObject; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearText.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearText.java new file mode 100644 index 000000000..85509acd4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearText.java @@ -0,0 +1,172 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearText( + Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + Move moveTo, + Move moveAway, + BaseQueryOptions common) implements QueryOperator, AggregateObjectFilter { + + public static NearText of(String... concepts) { + return of(Target.text(Arrays.asList(concepts)), ObjectBuilder.identity()); + } + + public static NearText of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearText of(String text, Function> fn) { + return of(Target.text(List.of(text)), fn); + } + + public static NearText of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearText(Builder builder) { + this( + builder.searchTarget, + builder.distance, + builder.certainty, + builder.rerank, + builder.moveTo, + builder.moveAway, + builder.baseOptions()); + } + + public static class Builder extends BaseVectorSearchBuilder { + // Required query parameters. + private final Target searchTarget; + + // Optional query parameter. + private Move moveTo; + private Move moveAway; + + public Builder(Target searchTarget) { + this.searchTarget = searchTarget; + } + + public final Builder moveTo(float force, Function> fn) { + this.moveTo = fn.apply(new Move.Builder(force)).build(); + return this; + } + + public final Builder moveAway(float force, Function> fn) { + this.moveAway = fn.apply(new Move.Builder(force)).build(); + return this; + } + + @Override + public final NearText build() { + return new NearText(this); + } + } + + public static record Move(Float force, List objects, List concepts) { + + public Move(Builder builder) { + this(builder.force, builder.objects, builder.concepts); + } + + public static class Builder implements ObjectBuilder { + private final Float force; + + private List objects = new ArrayList<>(); + private List concepts = new ArrayList<>(); + + public Builder(float force) { + this.force = force; + } + + public final Builder uuids(String... uuids) { + this.objects = Arrays.asList(uuids); + return this; + } + + public final Builder concepts(String... concepts) { + this.concepts = Arrays.asList(concepts); + return this; + } + + @Override + public Move build() { + return new Move(this); + } + } + + public final void appendTo(WeaviateProtoBaseSearch.NearTextSearch.Move.Builder move) { + move.setForce(force); + if (!objects.isEmpty()) { + move.addAllUuids(objects); + } + if (!concepts.isEmpty()) { + move.addAllConcepts(concepts); + } + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearText(protoBuilder(true)); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearText(protoBuilder(true)); + } + + // Package-private for Hybrid to see. + WeaviateProtoBaseSearch.NearTextSearch.Builder protoBuilder(boolean withTargets) { + var nearText = WeaviateProtoBaseSearch.NearTextSearch.newBuilder(); + + if (searchTarget instanceof TextTarget text) { + nearText.addAllQuery(text.query()); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearText.addAllQuery(combined.query()); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (withTargets && searchTarget.appendTargets(targets)) { + nearText.setTargets(targets); + } + + if (certainty != null) { + nearText.setCertainty(certainty); + } else if (distance != null) { + nearText.setDistance(distance); + } + + if (moveTo != null) { + var to = WeaviateProtoBaseSearch.NearTextSearch.Move.newBuilder(); + moveTo.appendTo(to); + nearText.setMoveTo(to); + } + + if (moveAway != null) { + var away = WeaviateProtoBaseSearch.NearTextSearch.Move.newBuilder(); + moveAway.appendTo(away); + nearText.setMoveAway(away); + } + + return nearText; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearThermal.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearThermal.java new file mode 100644 index 000000000..dc91ed03e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearThermal.java @@ -0,0 +1,90 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearThermal(Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearThermal of(String thermal) { + return of(Target.blob(thermal)); + } + + public static NearThermal of(String thermal, Function> fn) { + return of(Target.blob(thermal), fn); + } + + public static NearThermal of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearThermal of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearThermal(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target searchTarget) { + super(searchTarget); + } + + @Override + public final NearThermal build() { + return new NearThermal(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearThermal(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearThermal(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearThermalSearch.Builder protoBuilder() { + var nearThermal = WeaviateProtoBaseSearch.NearThermalSearch.newBuilder(); + if (searchTarget instanceof TextTarget thermal) { + nearThermal.setThermal(thermal.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearThermal.setThermal(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearThermal.setTargets(targets); + } + + if (certainty != null) { + nearThermal.setCertainty(certainty); + } else if (distance != null) { + nearThermal.setDistance(distance); + } + return nearThermal; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVector.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVector.java new file mode 100644 index 000000000..134c019c9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVector.java @@ -0,0 +1,95 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearVector(NearVectorTarget searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static final NearVector of(float[] vector) { + return of(vector, ObjectBuilder.identity()); + } + + public static final NearVector of(float[] vector, Function> fn) { + return fn.apply(new Builder(Target.vector(vector))).build(); + } + + public static final NearVector of(float[][] vector) { + return of(vector, ObjectBuilder.identity()); + } + + public static final NearVector of(float[][] vector, Function> fn) { + return fn.apply(new Builder(Target.vector(vector))).build(); + } + + public static final NearVector of(NearVectorTarget searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static final NearVector of(NearVectorTarget searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearVector(Builder builder) { + this(builder.searchTarget, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends BaseVectorSearchBuilder { + // Required query parameters. + private final NearVectorTarget searchTarget; + + public Builder(NearVectorTarget searchTarget) { + this.searchTarget = searchTarget; + } + + @Override + public final NearVector build() { + return new NearVector(this); + } + } + + @Override + public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearVector(protoBuilder(true)); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearVector(protoBuilder(true)); + } + + WeaviateProtoBaseSearch.NearVector.Builder protoBuilder(boolean withTargets) { + var nearVector = WeaviateProtoBaseSearch.NearVector.newBuilder(); + + searchTarget.appendVectors(nearVector); + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (withTargets && searchTarget.appendTargets(targets)) { + nearVector.setTargets(targets); + } + + if (certainty != null) { + nearVector.setCertainty(certainty); + } else if (distance != null) { + nearVector.setDistance(distance); + } + return nearVector; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVectorTarget.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVectorTarget.java new file mode 100644 index 000000000..92e2cfa7b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVectorTarget.java @@ -0,0 +1,7 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; + +public interface NearVectorTarget extends Target { + void appendVectors(WeaviateProtoBaseSearch.NearVector.Builder req); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVideo.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVideo.java new file mode 100644 index 000000000..fb8974216 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/NearVideo.java @@ -0,0 +1,91 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.aggregate.AggregateObjectFilter; +import io.weaviate.client6.v1.api.collections.query.Target.CombinedTextTarget; +import io.weaviate.client6.v1.api.collections.query.Target.TextTarget; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record NearVideo( + Target searchTarget, + Float distance, + Float certainty, + Rerank rerank, + BaseQueryOptions common) + implements QueryOperator, AggregateObjectFilter { + + public static NearVideo of(String video) { + return of(Target.blob(video)); + } + + public static NearVideo of(String video, Function> fn) { + return of(Target.blob(video), fn); + } + + public static NearVideo of(Target searchTarget) { + return of(searchTarget, ObjectBuilder.identity()); + } + + public static NearVideo of(Target searchTarget, Function> fn) { + return fn.apply(new Builder(searchTarget)).build(); + } + + public NearVideo(Builder builder) { + this( + builder.media, + builder.distance, + builder.certainty, + builder.rerank, + builder.baseOptions()); + } + + public static class Builder extends NearMediaBuilder { + public Builder(Target searchTarget) { + super(searchTarget); + } + + @Override + public final NearVideo build() { + return new NearVideo(this); + } + } + + @Override + public void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + common.appendTo(req); + req.setNearVideo(protoBuilder()); + } + + @Override + public void appendTo(WeaviateProtoAggregate.AggregateRequest.Builder req) { + if (common.limit() != null) { + req.setLimit(common.limit()); + } + req.setNearVideo(protoBuilder()); + } + + private WeaviateProtoBaseSearch.NearVideoSearch.Builder protoBuilder() { + var nearVideo = WeaviateProtoBaseSearch.NearVideoSearch.newBuilder(); + if (searchTarget instanceof TextTarget video) { + nearVideo.setVideo(video.query().get(0)); + } else if (searchTarget instanceof CombinedTextTarget combined) { + nearVideo.setVideo(combined.query().get(0)); + } + + var targets = WeaviateProtoBaseSearch.Targets.newBuilder(); + if (searchTarget.appendTargets(targets)) { + nearVideo.setTargets(targets); + } + + if (certainty != null) { + nearVideo.setCertainty(certainty); + } else if (distance != null) { + nearVideo.setDistance(distance); + } + return nearVideo; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryMetadata.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryMetadata.java new file mode 100644 index 000000000..dd8a54bfb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryMetadata.java @@ -0,0 +1,53 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record QueryMetadata( + Float distance, + /** Distance metric normalized to {@code 0 <= c <= 1} range. */ + Float certainty, + /** BM25 ranking score. */ + Float score, + /** Components of the BM25 ranking score. */ + String explainScore) { + + private QueryMetadata(Builder builder) { + this( + builder.distance, + builder.certainty, + builder.score, + builder.explainScore); + } + + static class Builder implements ObjectBuilder { + private Float distance; + private Float certainty; + private Float score; + private String explainScore; + + final Builder distance(Float distance) { + this.distance = distance; + return this; + } + + final Builder certainty(Float certainty) { + this.certainty = certainty; + return this; + } + + final Builder score(Float score) { + this.score = score; + return this; + } + + final Builder explainScore(String explainScore) { + this.explainScore = explainScore; + return this; + } + + @Override + public final QueryMetadata build() { + return new QueryMetadata(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryObjectGrouped.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryObjectGrouped.java new file mode 100644 index 000000000..9f8ca1133 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryObjectGrouped.java @@ -0,0 +1,25 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; + +public record QueryObjectGrouped( + String uuid, + Vectors vectors, + /** Object properties. */ + PropertiesT properties, + /** Object metadata. */ + QueryMetadata metadata, + /** Name of the group that the object belongs to. */ + String belongsToGroup) { + + QueryObjectGrouped(WeaviateObject object, + String belongsToGroup) { + this( + object.uuid(), + object.vectors(), + object.properties(), + object.queryMetadata(), + belongsToGroup); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java new file mode 100644 index 000000000..886fd5b19 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public interface QueryOperator { + default BaseQueryOptions common() { + return null; + } + + default Rerank rerank() { + return null; + } + + /** Append QueryOperator to the request message. */ + void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryReference.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryReference.java new file mode 100644 index 000000000..fa6f9c7cb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryReference.java @@ -0,0 +1,181 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.query.Metadata.MetadataField; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record QueryReference( + String property, + String collection, + List includeVectors, + List returnProperties, + List returnReferences, + List returnMetadata) { + + public QueryReference(Builder options) { + this( + options.property, + options.collection, + new ArrayList<>(options.includeVectors), + new ArrayList<>(options.returnProperties), + options.returnReferences, + new ArrayList<>(options.returnMetadata)); + } + + /** + * Retrieve object referenced by a single-target cross-reference property. + * + * @param property Name of the cross-reference property. + */ + public static QueryReference single(String property) { + return single(property, ObjectBuilder.identity()); + } + + /** + * Retrieve object referenced by a single-target cross-reference property. + * + * @param property Name of the cross-reference property. + * @param fn Lambda expression for optional parameters. + */ + public static QueryReference single(String property, Function> fn) { + return fn.apply(new Builder(null, property)).build(); + } + + // TODO: check if we can supply mutiple collections + + /** + * Retrieve object referenced by a multi-target cross-reference property. + * + * @param property Name of the cross-reference property. + * @param collection Name of the target collection. + */ + public static QueryReference multi(String property, String collection) { + return multi(property, collection, ObjectBuilder.identity()); + } + + /** + * Retrieve object referenced by a multi-target cross-reference property. + * + * @param property Name of the cross-reference property. + * @param collection Name of the target collection. + * @param fn Lambda expression for optional parameters. + */ + public static QueryReference multi(String property, String collection, + Function> fn) { + return fn.apply(new Builder(collection, property)).build(); + } + + public static class Builder implements ObjectBuilder { + private final String property; + private final String collection; + + private Set includeVectors = new HashSet<>(); + private Set returnProperties = new HashSet<>(); + private List returnReferences = new ArrayList<>(); + private Set returnMetadata = new HashSet<>(); + + public Builder(String collection, String property) { + this.property = property; + this.collection = collection; + returnMetadata(MetadataField.UUID); + } + + /** Select vectors to return for each referenced object. */ + public final Builder includeVectors(String... vectors) { + this.includeVectors.addAll(Arrays.asList(vectors)); + return this; + } + + /** Select properties to return for each referenced object. */ + public final Builder returnProperties(String... properties) { + return returnProperties(Arrays.asList(properties)); + } + + /** Select properties to return for each referenced object. */ + public final Builder returnProperties(List properties) { + this.returnProperties.addAll(properties); + return this; + } + + /** Select nested references to return for each referenced object. */ + public final Builder returnReferences(QueryReference... references) { + return returnReferences(Arrays.asList(references)); + } + + /** Select nested references to return for each referenced object. */ + public final Builder returnReferences(List references) { + this.returnReferences.addAll(references); + return this; + } + + /** Select metadata to return about each referenced object. */ + public final Builder returnMetadata(Metadata... metadata) { + return returnMetadata(Arrays.asList(metadata)); + } + + /** Select metadata to return about each referenced object. */ + public final Builder returnMetadata(List metadata) { + this.returnMetadata.addAll(metadata); + return this; + } + + /** Include the default vector of the referenced object. */ + public final Builder includeVector() { + return returnMetadata(MetadataField.VECTOR); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(String... vectors) { + return includeVector(Arrays.asList(vectors)); + } + + /** Include one or more named vectors in the metadata response. */ + public final Builder includeVector(List vectors) { + this.includeVectors.addAll(vectors); + return this; + } + + @Override + public QueryReference build() { + return new QueryReference(this); + } + } + + public void appendTo(WeaviateProtoSearchGet.RefPropertiesRequest.Builder references) { + references.setReferenceProperty(property); + if (collection != null) { + references.setTargetCollection(collection); + } + + if (!returnMetadata.isEmpty()) { + var metadata = WeaviateProtoSearchGet.MetadataRequest.newBuilder(); + returnMetadata.forEach(m -> m.appendTo(metadata)); + metadata.addAllVectors(includeVectors); + references.setMetadata(metadata); + } + + if (!returnProperties.isEmpty() || !returnReferences.isEmpty()) { + var properties = WeaviateProtoSearchGet.PropertiesRequest.newBuilder(); + + if (!returnProperties.isEmpty()) { + properties.addAllNonRefProperties(returnProperties); + } + + if (!returnReferences.isEmpty()) { + returnReferences.forEach(r -> { + var ref = WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder(); + r.appendTo(ref); + properties.addRefProperties(ref); + }); + } + references.setProperties(properties); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java new file mode 100644 index 000000000..625dde30d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java @@ -0,0 +1,64 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record QueryRequest(QueryOperator operator, GroupBy groupBy) { + + static Rpc, WeaviateProtoSearchGet.SearchReply> rpc( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + return Rpc.of( + request -> QueryRequest.marshal(request, collection, defaults), + reply -> QueryResponse.unmarshal(reply, collection), + () -> WeaviateBlockingStub::search, + () -> WeaviateFutureStub::search); + } + + public static WeaviateProtoSearchGet.SearchRequest marshal( + QueryRequest request, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var message = WeaviateProtoSearchGet.SearchRequest.newBuilder(); + message.setUses127Api(true); + message.setUses125Api(true); + message.setUses123Api(true); + message.setCollection(collection.collectionName()); + + if (request.operator.common() != null) { + request.operator.common().appendTo(message); + } + if (request.operator.rerank() != null) { + request.operator.rerank().appendTo(message); + } + request.operator.appendTo(message); + + if (defaults.tenant() != null) { + message.setTenant(defaults.tenant()); + } + if (defaults.consistencyLevel() != null) { + defaults.consistencyLevel().appendTo(message); + } + + if (request.groupBy != null) { + request.groupBy.appendTo(message); + } + + return message.build(); + } + + static Rpc, WeaviateProtoSearchGet.SearchReply> grouped( + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var rpc = rpc(collection, defaults); + return Rpc.of( + request -> rpc.marshal(request), + reply -> QueryResponseGrouped.unmarshal(reply, collection, defaults), + () -> rpc.method(), () -> rpc.methodAsync()); + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponse.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponse.java new file mode 100644 index 000000000..b1bc7369e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponse.java @@ -0,0 +1,253 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.stream.Stream; + +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; +import io.weaviate.client6.v1.api.collections.Reference; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.DateUtil; +import io.weaviate.client6.v1.internal.grpc.ByteStringUtil; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.orm.PropertiesBuilder; + +public record QueryResponse( + List> objects) { + + static QueryResponse unmarshal(WeaviateProtoSearchGet.SearchReply reply, + CollectionDescriptor collection) { + var objects = reply + .getResultsList() + .stream() + .map(obj -> QueryResponse.unmarshalResultObject( + obj.getProperties(), obj.getMetadata(), collection)) + .toList(); + return new QueryResponse<>(objects); + } + + public static WeaviateObject unmarshalResultObject( + WeaviateProtoSearchGet.PropertiesResult propertiesResult, + WeaviateProtoSearchGet.MetadataResult metadataResult, + CollectionDescriptor collection) { + var object = unmarshalWithReferences(propertiesResult, metadataResult, collection); + + Long createdAt = null; + Long lastUpdatedAt = null; + var metadata = new QueryMetadata.Builder(); + + if (metadataResult.getCreationTimeUnixPresent()) { + createdAt = metadataResult.getCreationTimeUnix(); + } + if (metadataResult.getLastUpdateTimeUnixPresent()) { + lastUpdatedAt = metadataResult.getLastUpdateTimeUnix(); + } + if (metadataResult.getDistancePresent()) { + metadata.distance(metadataResult.getDistance()); + } + if (metadataResult.getCertaintyPresent()) { + metadata.certainty(metadataResult.getCertainty()); + } + if (metadataResult.getScorePresent()) { + metadata.score(metadataResult.getScore()); + } + if (metadataResult.getExplainScorePresent()) { + metadata.explainScore(metadataResult.getExplainScore()); + } + return new WeaviateObject<>( + object.uuid(), + collection.collectionName(), + null, // tenant is not reeturned in the query + object.properties(), + object.vectors(), + createdAt, + lastUpdatedAt, + metadata.build(), + object.references()); + } + + static WeaviateObject unmarshalWithReferences( + WeaviateProtoSearchGet.PropertiesResult propertiesResult, + WeaviateProtoSearchGet.MetadataResult metadataResult, + CollectionDescriptor descriptor) { + var properties = descriptor.propertiesBuilder(); + propertiesResult.getNonRefProps().getFieldsMap().entrySet().stream() + .forEach(entry -> setProperty(entry.getKey(), entry.getValue(), properties, descriptor)); + + // In case a reference is multi-target, there will be a separate + // "reference property" for each of the targets, so instead of + // `collect` we need to `reduce` the map, merging related references + // as we go. + // I.e. { "ref": A-1 } , { "ref": B-1 } => { "ref": [A-1, B-1] } + var referenceProperties = propertiesResult.getRefPropsList() + .stream().reduce( + new HashMap>(), + (map, ref) -> { + var refObjects = ref.getPropertiesList().stream() + .map(property -> { + var reference = unmarshalWithReferences( + property, property.getMetadata(), + CollectionDescriptor.ofMap(property.getTargetCollection())); + return (Reference) new WeaviateObject<>( + reference.uuid(), + reference.collection(), + // TODO(dyma): we can get tenant from CollectionHandle + null, // tenant is not returned in the query + (Map) reference.properties(), + reference.vectors(), + reference.createdAt(), + reference.lastUpdatedAt(), + reference.queryMetadata(), + reference.references()); + }) + .toList(); + + // Merge ObjectReferences by joining the underlying WeaviateObjects. + map.merge( + ref.getPropName(), + refObjects, + (left, right) -> { + var joined = Stream.concat( + left.stream(), + right.stream()).toList(); + return joined; + }); + return map; + }, + (left, right) -> { + left.putAll(right); + return left; + }); + + String uuid = null; + Vectors vectors = null; + QueryMetadata metadata = null; + if (metadataResult != null) { + var metadataBuilder = new QueryMetadata.Builder(); + + uuid = metadataResult.getId(); + + // Read legacy (unnamed) vector. + if (metadataResult.getVectorBytes() != null && !metadataResult.getVectorBytes().isEmpty()) { + var unnamed = ByteStringUtil.decodeVectorSingle(metadataResult.getVectorBytes()); + vectors = Vectors.of(unnamed); + } else { + var namedVectors = new Vectors[metadataResult.getVectorsList().size()]; + var i = 0; + for (final var vector : metadataResult.getVectorsList()) { + var vectorName = vector.getName(); + var vbytes = vector.getVectorBytes(); + switch (vector.getType()) { + case VECTOR_TYPE_SINGLE_FP32: + namedVectors[i++] = Vectors.of(vectorName, ByteStringUtil.decodeVectorSingle(vbytes)); + break; + case VECTOR_TYPE_MULTI_FP32: + namedVectors[i++] = Vectors.of(vectorName, ByteStringUtil.decodeVectorMulti(vbytes)); + break; + default: + continue; + } + } + vectors = new Vectors(namedVectors); + } + + metadata = metadataBuilder.build(); + } + + return new WeaviateObject<>( + uuid, + descriptor.collectionName(), + null, // tenant is not returned in the query + properties.build(), + vectors, + null, + null, + metadata, + referenceProperties); + } + + static void setProperty(String property, WeaviateProtoProperties.Value value, + PropertiesBuilder builder, CollectionDescriptor descriptor) { + if (value.hasNullValue()) { + builder.setNull(property); + } else if (value.hasTextValue()) { + builder.setText(property, value.getTextValue()); + } else if (value.hasBoolValue()) { + builder.setBoolean(property, value.getBoolValue()); + } else if (value.hasIntValue()) { + builder.setLong(property, value.getIntValue()); + } else if (value.hasNumberValue()) { + builder.setDouble(property, value.getNumberValue()); + } else if (value.hasBlobValue()) { + builder.setBlob(property, value.getBlobValue()); + } else if (value.hasDateValue()) { + builder.setOffsetDateTime(property, DateUtil.fromISO8601(value.getDateValue())); + } else if (value.hasUuidValue()) { + builder.setUuid(property, UUID.fromString(value.getUuidValue())); + } else if (value.hasPhoneValue()) { + var phone = value.getPhoneValue(); + builder.setPhoneNumber(property, new PhoneNumber( + phone.getInput(), + phone.getDefaultCountry(), + Long.valueOf(phone.getCountryCode()).intValue(), + phone.getInternationalFormatted(), + Long.valueOf(phone.getNational()).intValue(), + phone.getNationalFormatted(), + phone.getValid())); + } else if (value.hasGeoValue()) { + var geo = value.getGeoValue(); + builder.setGeoCoordinates(property, new GeoCoordinates( + geo.getLatitude(), + geo.getLongitude())); + } else if (value.hasListValue()) { + var list = value.getListValue(); + if (list.hasTextValues()) { + builder.setTextArray(property, list.getTextValues().getValuesList()); + } else if (list.hasIntValues()) { + var ints = Arrays.stream( + ByteStringUtil.decodeIntValues(list.getIntValues().getValues())) + .boxed().toList(); + builder.setLongArray(property, ints); + } else if (list.hasNumberValues()) { + var numbers = Arrays.stream( + ByteStringUtil.decodeNumberValues(list.getNumberValues().getValues())) + .boxed().toList(); + builder.setDoubleArray(property, numbers); + } else if (list.hasUuidValues()) { + var uuids = list.getUuidValues().getValuesList().stream() + .map(UUID::fromString).toList(); + builder.setUuidArray(property, uuids); + } else if (list.hasBoolValues()) { + builder.setBooleanArray(property, list.getBoolValues().getValuesList()); + } else if (list.hasDateValues()) { + var dates = list.getDateValues().getValuesList().stream() + .map(DateUtil::fromISO8601).toList(); + builder.setOffsetDateTimeArray(property, dates); + } else if (list.hasObjectValues()) { + List objects = list.getObjectValues().getValuesList().stream() + .map(object -> { + var properties = descriptor.propertiesBuilder(); + object.getFieldsMap().entrySet().stream() + .forEach(entry -> setProperty(entry.getKey(), entry.getValue(), properties, descriptor)); + return properties.build(); + }).toList(); + builder.setNestedObjectArray(property, objects); + } + } else if (value.hasObjectValue()) { + var object = value.getObjectValue(); + var properties = descriptor.propertiesBuilder(); + object.getFieldsMap().entrySet().stream() + .forEach(entry -> setProperty(entry.getKey(), entry.getValue(), properties, descriptor)); + builder.setNestedObject(property, properties.build()); + } else { + throw new IllegalArgumentException(property + " data type is not supported"); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGroup.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGroup.java new file mode 100644 index 000000000..5ad750051 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGroup.java @@ -0,0 +1,22 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.List; + +public record QueryResponseGroup( + /** Group name. */ + String name, + /** + * The smallest distance value among all objects in the group, indicating the + * most similar object in that group to the query + */ + Float minDistance, + /** + * The largest distance value among all objects in the group, indicating the + * least similar object in that group to the query. + */ + Float maxDistance, + /** The size of the group. */ + long numberOfObjects, + /** Objects retrieved in the query. */ + List> objects) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGrouped.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGrouped.java new file mode 100644 index 000000000..587be10ac --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryResponseGrouped.java @@ -0,0 +1,52 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record QueryResponseGrouped( + /** All objects retrieved in the query. */ + List> objects, + /** Grouped response objects. */ + Map> groups) { + + static QueryResponseGrouped unmarshal( + WeaviateProtoSearchGet.SearchReply reply, + CollectionDescriptor collection, + CollectionHandleDefaults defaults) { + var allObjects = new ArrayList>(); + var groups = reply.getGroupByResultsList() + .stream().map(group -> { + var name = group.getName(); + List> objects = group.getObjectsList().stream() + .map(obj -> QueryResponse.unmarshalResultObject( + obj.getProperties(), + obj.getMetadata(), + collection)) + .map(obj -> new QueryObjectGrouped<>(obj, name)) + .toList(); + + allObjects.addAll(objects); + return new QueryResponseGroup<>( + name, + group.getMinDistance(), + group.getMaxDistance(), + group.getNumberOfObjects(), + objects); + }) + // Collectors.toMap() throws an NPE if either key or value in the map are null. + // In this specific case it is safe to use it, as the function in the map above + // always returns a QueryResponseGroup. + // The name of the group should not be null either, that's something we assume + // about the server's response. + .collect(Collectors.toMap(QueryResponseGroup::name, Function.identity())); + + return new QueryResponseGrouped(allObjects, groups); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Rerank.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Rerank.java new file mode 100644 index 000000000..76b3fb6ec --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Rerank.java @@ -0,0 +1,50 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet; + +public record Rerank(String property, String query) { + + public static Rerank by(String property) { + return by(property, ObjectBuilder.identity()); + } + + public static Rerank by(String property, Function> fn) { + return fn.apply(new Builder(property)).build(); + } + + void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) { + var rerank = WeaviateProtoSearchGet.Rerank.newBuilder() + .setProperty(property); + + if (query != null) { + rerank.setQuery(query); + } + req.setRerank(rerank); + } + + public Rerank(Builder builder) { + this(builder.property, builder.query); + } + + public static class Builder implements ObjectBuilder { + private final String property; + private String query; + + public Builder(String property) { + this.property = property; + } + + public Builder query(String query) { + this.query = query; + return this; + } + + @Override + public Rerank build() { + return new Rerank(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/SearchOperator.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/SearchOperator.java new file mode 100644 index 000000000..8fa1ee1ec --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/SearchOperator.java @@ -0,0 +1,31 @@ +package io.weaviate.client6.v1.api.collections.query; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator; + +public class SearchOperator { + private final String operator; + private final Integer minimumOrTokensMatch; + + public static final SearchOperator or(int minimumOrTokensMatch) { + return new SearchOperator("Or", minimumOrTokensMatch); + } + + public static final SearchOperator and() { + return new SearchOperator("And", 0); + } + + private SearchOperator(String operator, Integer minimumOrTokensMatch) { + this.operator = operator; + this.minimumOrTokensMatch = minimumOrTokensMatch; + } + + void appendTo(WeaviateProtoBaseSearch.BM25.Builder req) { + var options = WeaviateProtoBaseSearch.SearchOperatorOptions.newBuilder(); + options.setOperator(operator == "And" ? Operator.OPERATOR_AND : Operator.OPERATOR_OR); + if (minimumOrTokensMatch != null) { + options.setMinimumOrTokensMatch(minimumOrTokensMatch); + } + req.setSearchOperator(options); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/SortBy.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/SortBy.java new file mode 100644 index 000000000..ebab47aca --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/SortBy.java @@ -0,0 +1,77 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.List; + +public record SortBy(List path, boolean ascending) { + /** + * Sort by object property. Ascending order by default. + * + * @see #desc() to sort in descending order. + */ + public static SortBy property(String property) { + return new SortBy(List.of(property), true); + } + + /** + * Sort by object's UUID. Ascending order by default. + * + *

+ * Sorting by UUID may be useful if objects are assigned + * custom UUIDv7 at ingestion, as those are "time-ordered". + * + *

+ * It may be less useful for the auto-generated UUIDs, + * which will produce an essentialy random, albeit stable, order. + * + * @see #desc() to sort in descending order. + */ + public static SortBy uuid() { + return property(BaseQueryOptions.ID_PROPERTY); + } + + /** + * Sort by object creation time. Ascending order by default. + * + * @see #desc() to sort in descending order. + */ + public static SortBy creationTime() { + return property("_creationTimeUnix"); + } + + /** + * Sort by object last update time. Ascending order by default. + * + * @see #desc() to sort in descending order. + */ + public static SortBy lastUpdateTime() { + return property("_lastUpdateTimeUnix"); + } + + /** + * Sort in ascending order. + * + *

+ * Example: + * + *

{@code
+   * SortBy.property("name").asc();
+   * }
+ */ + public SortBy asc() { + return new SortBy(path, true); + } + + /** + * Sort in descending order. + * + *

+ * Example: + * + *

{@code
+   * SortBy.property("name").desc();
+   * }
+ */ + public SortBy desc() { + return new SortBy(path, false); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/Target.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/Target.java new file mode 100644 index 000000000..03d113197 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/Target.java @@ -0,0 +1,345 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.stream.Collectors; + +import com.google.protobuf.ByteString; + +import io.weaviate.client6.v1.internal.grpc.ByteStringUtil; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; + +public interface Target { + + boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req); + + record VectorTarget( + /** Name of the vector index to search compare the input vector to. */ + String vectorName, + /** + * Weight assigned to this vector distance. Only required with + * RELATIVE_SCORE and MANUAL combination methods. + */ + Float weight, + /** Query vector. Must be either {@code float[]} or {@code float[][]}. */ + Object vector) implements NearVectorTarget { + + /** + * Append target vector name and, if provided, the weight it should be assigned. + */ + @Override + public boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req) { + if (vectorName == null) { + return false; + } + req.addTargetVectors(vectorName); + + if (weight != null) { + req.addWeightsForTargets(WeaviateProtoBaseSearch.WeightsForTarget.newBuilder() + .setTarget(vectorName) + .setWeight(weight)); + } + return true; + } + + /** + * Append vectors if this is a single target vector. + * Must not be called from {@link CombinedVectorTarget}. + */ + @Override + public void appendVectors(WeaviateProtoBaseSearch.NearVector.Builder req) { + if (vectorName == null) { + req.addVectors(encodeVectors()); + } else { + req.addVectorForTargets(WeaviateProtoBaseSearch.VectorForTarget.newBuilder() + .setName(vectorName) + .addVectors(encodeVectors())); + } + } + + /** + * Encode search vector as a {@link ByteString} + * with the corresponding type (single/multi). + */ + private WeaviateProtoBase.Vectors.Builder encodeVectors() { + assert vector instanceof float[] || vector instanceof float[][]; + + return vector instanceof float[] single + ? WeaviateProtoBase.Vectors.newBuilder() + .setType(WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_SINGLE_FP32) + .setVectorBytes(ByteStringUtil.encodeVectorSingle(single)) + : WeaviateProtoBase.Vectors.newBuilder() + .setType(WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_MULTI_FP32) + .setVectorBytes(ByteStringUtil.encodeVectorMulti((float[][]) vector)); + } + } + + static VectorTarget vector(float[] vector) { + return new VectorTarget(null, null, vector); + } + + static VectorTarget vector(float[][] vector) { + return new VectorTarget(null, null, vector); + } + + static VectorTarget vector(String vectorName, float[] vector) { + return new VectorTarget(vectorName, null, vector); + } + + static VectorTarget vector(String vectorName, float[][] vector) { + return new VectorTarget(vectorName, null, vector); + } + + static VectorTarget vector(String vectorName, float weight, float[] vector) { + return new VectorTarget(vectorName, weight, vector); + } + + static VectorTarget vector(String vectorName, float weight, float[][] vector) { + return new VectorTarget(vectorName, weight, vector); + } + + static NearVectorTarget combine(CombinationMethod combinationMethod, VectorTarget... vectorTargets) { + return new CombinedVectorTarget(combinationMethod, Arrays.asList(vectorTargets)); + } + + static NearVectorTarget sum(VectorTarget... vectorTargets) { + return combine(CombinationMethod.SUM, vectorTargets); + } + + static NearVectorTarget min(VectorTarget... vectorTargets) { + return combine(CombinationMethod.MIN, vectorTargets); + } + + static NearVectorTarget average(VectorTarget... vectorTargets) { + return combine(CombinationMethod.AVERAGE, vectorTargets); + } + + static NearVectorTarget relativeScore(VectorTarget... vectorTargets) { + return combine(CombinationMethod.RELATIVE_SCORE, vectorTargets); + } + + static NearVectorTarget manualWeights(VectorTarget... vectorTargets) { + return combine(CombinationMethod.MANUAL_WEIGHTS, vectorTargets); + } + + enum CombinationMethod { + SUM, + MIN, + AVERAGE, + RELATIVE_SCORE, + MANUAL_WEIGHTS; + } + + record CombinedVectorTarget(CombinationMethod combinationMethod, List targets) + implements NearVectorTarget { + + @Override + public boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req) { + if (targets.isEmpty()) { + return false; + } + switch (combinationMethod) { + case SUM: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_SUM); + break; + case MIN: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_MIN); + break; + case AVERAGE: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_AVERAGE); + break; + case RELATIVE_SCORE: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_RELATIVE_SCORE); + break; + case MANUAL_WEIGHTS: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_MANUAL); + break; + } + targets.forEach(t -> t.appendTargets(req)); + return true; + } + + @Override + /** Append combined vector targets. */ + public void appendVectors(WeaviateProtoBaseSearch.NearVector.Builder req) { + if (targets.isEmpty()) { + return; + } + + // We use LinkedHashMap to preserve insertion order. + // This has negligble performance penalty, if any, + // but allows for a predictable output in tests. + targets + .stream() + .collect(Collectors.groupingBy( + VectorTarget::vectorName, + LinkedHashMap::new, + Collectors.toList())) + .entrySet() + .forEach(target -> { + var vectorForTargets = WeaviateProtoBaseSearch.VectorForTarget.newBuilder() + .setName(target.getKey()); + target.getValue().forEach(vt -> { + vectorForTargets.addVectors(vt.encodeVectors()); + }); + req.addVectorForTargets(vectorForTargets); + }); + } + } + + record TextTarget(VectorWeight weight, List query) implements Target { + + private TextTarget(String vectorName, Float weight, List query) { + this(new VectorWeight(vectorName, weight), query); + } + + @Override + public boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req) { + return weight.appendTargets(req); + } + } + + static TextTarget text(List text) { + return new TextTarget(null, null, text); + } + + static TextTarget text(String vectorName, String... text) { + return new TextTarget(vectorName, null, Arrays.asList(text)); + } + + static TextTarget text(String vectorName, float weight, String... text) { + return new TextTarget(vectorName, weight, Arrays.asList(text)); + } + + static TextTarget blob(String blob) { + return new TextTarget(null, null, Collections.singletonList(blob)); + } + + static TextTarget blob(String vectorName, String blob) { + return new TextTarget(vectorName, null, Collections.singletonList(blob)); + } + + static TextTarget blob(String vectorName, float weight, String blob) { + return new TextTarget(vectorName, weight, Collections.singletonList(blob)); + } + + static TextTarget uuid(String uuid) { + return new TextTarget(null, null, Collections.singletonList(uuid)); + } + + static TextTarget uuid(String vectorName, String uuid) { + return new TextTarget(vectorName, null, Collections.singletonList(uuid)); + } + + static TextTarget uuid(String vectorName, float weight, String uuid) { + return new TextTarget(vectorName, weight, Collections.singletonList(uuid)); + } + + /** + * Weight to be applied to the vector distance. Used for text-based + * queries where only a single input is allowed. + */ + record VectorWeight(String vectorName, Float weight) { + public boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req) { + if (vectorName == null) { + return false; + } + req.addTargetVectors(vectorName); + + if (weight != null) { + req.addWeightsForTargets(WeaviateProtoBaseSearch.WeightsForTarget.newBuilder() + .setTarget(vectorName) + .setWeight(weight)); + } + return true; + } + } + + record CombinedTextTarget(List query, CombinationMethod combinationMethod, List vectorWeights) + implements Target { + + @Override + public boolean appendTargets(WeaviateProtoBaseSearch.Targets.Builder req) { + if (vectorWeights.isEmpty()) { + return false; + } + switch (combinationMethod) { + case SUM: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_SUM); + break; + case MIN: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_MIN); + break; + case AVERAGE: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_AVERAGE); + break; + case RELATIVE_SCORE: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_RELATIVE_SCORE); + break; + case MANUAL_WEIGHTS: + req.setCombination(WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_TYPE_MANUAL); + break; + } + vectorWeights.forEach(t -> t.appendTargets(req)); + return true; + } + } + + static VectorWeight weight(String vectorName, float weight) { + return new VectorWeight(vectorName, weight); + } + + static Target combine(List query, CombinationMethod combinationMethod, VectorWeight... vectorWeights) { + return new CombinedTextTarget(query, combinationMethod, Arrays.asList(vectorWeights)); + } + + static Target combine(List query, CombinationMethod combinationMethod, String... targetVectors) { + var vectorWeights = Arrays.stream(targetVectors) + .map(vw -> new VectorWeight(vw, null)) + .toArray(VectorWeight[]::new); + return combine(query, combinationMethod, vectorWeights); + } + + static Target sum(String query, String... targetVectors) { + return sum(List.of(query), targetVectors); + } + + static Target sum(List query, String... targetVectors) { + return combine(query, CombinationMethod.SUM, targetVectors); + } + + static Target min(String query, String... targetVectors) { + return min(List.of(query), targetVectors); + } + + static Target min(List query, String... targetVectors) { + return combine(query, CombinationMethod.MIN, targetVectors); + } + + static Target average(String query, String... targetVectors) { + return average(List.of(query), targetVectors); + } + + static Target average(List query, String... targetVectors) { + return combine(query, CombinationMethod.AVERAGE, targetVectors); + } + + static Target relativeScore(String query, VectorWeight... weights) { + return relativeScore(List.of(query), weights); + } + + static Target relativeScore(List query, VectorWeight... weights) { + return combine(query, CombinationMethod.RELATIVE_SCORE, weights); + } + + static Target manualWeights(String query, VectorWeight... weights) { + return manualWeights(List.of(query), weights); + } + + static Target manualWeights(List query, VectorWeight... weights) { + return combine(query, CombinationMethod.MANUAL_WEIGHTS, weights); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java new file mode 100644 index 000000000..25e899b56 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java @@ -0,0 +1,45 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.Optional; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateQueryClient + extends + AbstractQueryClient>, QueryResponse, QueryResponseGrouped> { + + public WeaviateQueryClient( + CollectionDescriptor collection, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + super(collection, grpcTransport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateQueryClient(WeaviateQueryClient c, CollectionHandleDefaults defaults) { + super(c, defaults); + } + + @Override + protected Optional> fetchObjectById(FetchObjectById byId) { + var request = new QueryRequest(byId, null); + var result = this.grpcTransport.performRequest(request, QueryRequest.rpc(collection, defaults)); + return optionalFirst(result); + + } + + @Override + protected final QueryResponse performRequest(QueryOperator operator) { + var request = new QueryRequest(operator, null); + return this.grpcTransport.performRequest(request, QueryRequest.rpc(collection, defaults)); + } + + @Override + protected final QueryResponseGrouped performRequest(QueryOperator operator, GroupBy groupBy) { + var request = new QueryRequest(operator, groupBy); + return this.grpcTransport.performRequest(request, QueryRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java new file mode 100644 index 000000000..41a7d902b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java @@ -0,0 +1,47 @@ +package io.weaviate.client6.v1.api.collections.query; + +import java.util.Optional; +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class WeaviateQueryClientAsync + extends + AbstractQueryClient>>, CompletableFuture>, CompletableFuture>> { + + public WeaviateQueryClientAsync( + CollectionDescriptor collection, + GrpcTransport grpcTransport, + CollectionHandleDefaults defaults) { + super(collection, grpcTransport, defaults); + } + + /** Copy constructor that sets new defaults. */ + public WeaviateQueryClientAsync(WeaviateQueryClientAsync qc, CollectionHandleDefaults defaults) { + super(qc, defaults); + } + + @Override + protected CompletableFuture>> fetchObjectById( + FetchObjectById byId) { + var request = new QueryRequest(byId, null); + var result = this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection, defaults)); + return result.thenApply(this::optionalFirst); + } + + @Override + protected final CompletableFuture> performRequest(QueryOperator operator) { + var request = new QueryRequest(operator, null); + return this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection, defaults)); + } + + @Override + protected final CompletableFuture> performRequest(QueryOperator operator, + GroupBy groupBy) { + var request = new QueryRequest(operator, groupBy); + return this.grpcTransport.performRequestAsync(request, QueryRequest.grouped(collection, defaults)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/CohereReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/CohereReranker.java new file mode 100644 index 000000000..5cdf60c16 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/CohereReranker.java @@ -0,0 +1,51 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record CohereReranker( + @SerializedName("model") String model) implements Reranker { + + public static final String RERANK_ENGLISH_V2 = "rerank-english-v2.0"; + public static final String RERANK_MULTILINGUAL_V2 = "rerank-multilingual-v2.0"; + + @Override + public Kind _kind() { + return Reranker.Kind.COHERE; + } + + @Override + public Object _self() { + return this; + } + + public static CohereReranker of() { + return of(ObjectBuilder.identity()); + } + + public static CohereReranker of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public CohereReranker(Builder builder) { + this(builder.model); + } + + public static class Builder implements ObjectBuilder { + private String model; + + public Builder model(String model) { + this.model = model; + return this; + } + + @Override + public CohereReranker build() { + return new CohereReranker(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/DummyReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/DummyReranker.java new file mode 100644 index 000000000..ce692ed3a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/DummyReranker.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import io.weaviate.client6.v1.api.collections.Reranker; + +public record DummyReranker() implements Reranker { + + @Override + public Kind _kind() { + return Reranker.Kind.DUMMY; + } + + @Override + public Object _self() { + return this; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/JinaAiReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/JinaAiReranker.java new file mode 100644 index 000000000..7c7996c3c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/JinaAiReranker.java @@ -0,0 +1,54 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record JinaAiReranker( + @SerializedName("model") String model) implements Reranker { + + public static final String BASE_MULTILINGUAL_V1 = "jina-reranker-v2-base-multilingual"; + public static final String BASE_ENGLISH_V1 = "jina-reranker-v1-base-en"; + public static final String TURBO_ENGLISH_V1 = "jina-reranker-v1-turbo-en"; + public static final String TINY_ENGLISH_V1 = "jina-reranker-v1-tiny-en"; + public static final String COLBERT_ENGLISH_V1 = "jina-colbert-v1-en"; + + @Override + public Kind _kind() { + return Reranker.Kind.JINAAI; + } + + @Override + public Object _self() { + return this; + } + + public static JinaAiReranker of() { + return of(ObjectBuilder.identity()); + } + + public static JinaAiReranker of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public JinaAiReranker(Builder builder) { + this(builder.model); + } + + public static class Builder implements ObjectBuilder { + private String model; + + public Builder model(String model) { + this.model = model; + return this; + } + + @Override + public JinaAiReranker build() { + return new JinaAiReranker(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/NvidiaReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/NvidiaReranker.java new file mode 100644 index 000000000..3ed849745 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/NvidiaReranker.java @@ -0,0 +1,55 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record NvidiaReranker( + @SerializedName("model") String model, + @SerializedName("baseUrl") String baseUrl) implements Reranker { + + @Override + public Kind _kind() { + return Reranker.Kind.NVIDIA; + } + + @Override + public Object _self() { + return this; + } + + public static NvidiaReranker of() { + return of(ObjectBuilder.identity()); + } + + public static NvidiaReranker of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public NvidiaReranker(Builder builder) { + this(builder.model, builder.baseUrl); + } + + public static class Builder implements ObjectBuilder { + private String model; + private String baseUrl; + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + @Override + public NvidiaReranker build() { + return new NvidiaReranker(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/TransformersReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/TransformersReranker.java new file mode 100644 index 000000000..a1dccfc78 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/TransformersReranker.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import io.weaviate.client6.v1.api.collections.Reranker; + +public record TransformersReranker() implements Reranker { + + @Override + public Kind _kind() { + return Reranker.Kind.NVIDIA; + } + + @Override + public Object _self() { + return this; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/VoyageAiReranker.java b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/VoyageAiReranker.java new file mode 100644 index 000000000..bb1c3757f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/rerankers/VoyageAiReranker.java @@ -0,0 +1,53 @@ +package io.weaviate.client6.v1.api.collections.rerankers; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record VoyageAiReranker( + @SerializedName("model") String model) implements Reranker { + + public static final String RERANK_1 = "rerank-1"; + public static final String RERANK_LITE_1 = "rerank-lite-1"; + public static final String RERANK_2 = "rerank-2"; + public static final String RERANK_LITE_2 = "rerank-2-lite"; + + @Override + public Kind _kind() { + return Reranker.Kind.VOYAGEAI; + } + + @Override + public Object _self() { + return this; + } + + public static VoyageAiReranker of() { + return of(ObjectBuilder.identity()); + } + + public static VoyageAiReranker of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public VoyageAiReranker(Builder builder) { + this(builder.model); + } + + public static class Builder implements ObjectBuilder { + private String model; + + public Builder model(String model) { + this.model = model; + return this; + } + + @Override + public VoyageAiReranker build() { + return new VoyageAiReranker(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java new file mode 100644 index 000000000..aa72ede5f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.util.Collections; +import java.util.List; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateTenantsRequest(List tenants) { + static Endpoint endpoint(CollectionDescriptor collection) { + return SimpleEndpoint.sideEffect( + __ -> "POST", + __ -> "/schema/" + collection.collectionName() + "/tenants", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.tenants)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java new file mode 100644 index 000000000..82f956ff7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.util.Collections; +import java.util.List; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record DeleteTenantsRequest(List tenants) { + static Endpoint endpoint(CollectionDescriptor collection) { + return SimpleEndpoint.sideEffect( + __ -> "DELETE", + __ -> "/schema/" + collection.collectionName() + "/tenants", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.tenants)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java new file mode 100644 index 000000000..1219c45c6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java @@ -0,0 +1,57 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.util.List; + +import io.weaviate.client6.v1.internal.grpc.Rpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public record GetTenantsRequest(List tenants) { + static final Rpc, WeaviateProtoTenants.TenantsGetReply> rpc( + CollectionDescriptor collection) { + return Rpc.of( + request -> { + var message = WeaviateProtoTenants.TenantsGetRequest.newBuilder() + .setCollection(collection.collectionName()); + + if (!request.tenants.isEmpty()) { + message.setNames(TenantNames.newBuilder() + .addAllValues(request.tenants) + .build()); + } + return message.build(); + }, + response -> { + return response.getTenantsList().stream() + .map(t -> { + TenantStatus status; + switch (t.getActivityStatus()) { + case TENANT_ACTIVITY_STATUS_ACTIVE, TENANT_ACTIVITY_STATUS_HOT: + status = TenantStatus.ACTIVE; + break; + case TENANT_ACTIVITY_STATUS_INACTIVE, TENANT_ACTIVITY_STATUS_COLD: + status = TenantStatus.INACTIVE; + break; + case TENANT_ACTIVITY_STATUS_FROZEN, TENANT_ACTIVITY_STATUS_OFFLOADED: + status = TenantStatus.OFFLOADED; + break; + case TENANT_ACTIVITY_STATUS_OFFLOADING, TENANT_ACTIVITY_STATUS_FREEZING: + status = TenantStatus.OFFLOADING; + break; + case TENANT_ACTIVITY_STATUS_ONLOADING, TENANT_ACTIVITY_STATUS_UNFREEZING: + status = TenantStatus.ONLOADING; + break; + default: + throw new RuntimeException("unknown tenant status " + t.getActivityStatus().toString()); + } + return new Tenant(t.getName(), status); + }) + .toList(); + }, + () -> WeaviateBlockingStub::tenantsGet, + () -> WeaviateFutureStub::tenantsGet); + }; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java new file mode 100644 index 000000000..519e19bd7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java @@ -0,0 +1,43 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import com.google.gson.annotations.SerializedName; + +public record Tenant( + @SerializedName("name") String name, + @SerializedName("activityStatus") TenantStatus status) { + + /** Create new tenant with {@link TenantStatus#ACTIVE}. */ + public static Tenant active(String name) { + return new Tenant(name, TenantStatus.ACTIVE); + } + + /** Create new tenant with {@link TenantStatus#INACTIVE}. */ + public static Tenant inactive(String name) { + return new Tenant(name, TenantStatus.INACTIVE); + } + + /** Returns true if tenant's status is {@link TenantStatus#ACTIVE}. */ + public boolean isActive() { + return status == TenantStatus.ACTIVE; + } + + /** Returns true if tenant's status is {@link TenantStatus#INACTIVE}. */ + public boolean isInactive() { + return status == TenantStatus.INACTIVE; + } + + /** Returns true if tenant's status is {@link TenantStatus#OFFLOADED}. */ + public boolean isOffloaded() { + return status == TenantStatus.OFFLOADED; + } + + /** Returns true if tenant's status is {@link TenantStatus#OFFLOADING}. */ + public boolean isOffloading() { + return status == TenantStatus.OFFLOADING; + } + + /** Returns true if tenant's status is {@link TenantStatus#ONLOADING}. */ + public boolean isOnloading() { + return status == TenantStatus.ONLOADING; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java new file mode 100644 index 000000000..74445af29 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; + +public record TenantExistsRequest(String tenant) { + static Endpoint endpoint(CollectionDescriptor collection) { + return new BooleanEndpoint<>( + __ -> "GET", + request -> "/schema/" + collection.collectionName() + "/tenants/" + request.tenant, + __ -> Collections.emptyMap(), + __ -> null); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java new file mode 100644 index 000000000..69b759a71 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java @@ -0,0 +1,28 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import com.google.gson.annotations.SerializedName; + +public enum TenantStatus { + /** The tenant is activated and can be readily used. */ + @SerializedName(value = "ACTIVE", alternate = "HOT") + ACTIVE, + /** + * Tenant needs to be activated before use. + * Files are stored locally on the node. + */ + @SerializedName(value = "INACTIVE", alternate = "COLD") + INACTIVE, + /** + * Tenant is inactive and will need to be onloaded before use. + * Files are stored in the configured remote (cloud) storage. + */ + @SerializedName(value = "OFFLOADED", alternate = "FROZEN") + OFFLOADED, + + /** Tenant is being offloaded to a remote storage. */ + @SerializedName(value = "OFFLOADING", alternate = "FREEZING") + OFFLOADING, + /** Tenant is being activated. */ + @SerializedName(value = "ONLOADING", alternate = "UNFREEZING") + ONLOADING; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java new file mode 100644 index 000000000..c17334be0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.util.Collections; +import java.util.List; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record UpdateTenantsRequest(List tenants) { + static Endpoint endpoint(CollectionDescriptor collection) { + return SimpleEndpoint.sideEffect( + __ -> "PUT", + __ -> "/schema/" + collection.collectionName() + "/tenants", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.tenants)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java new file mode 100644 index 000000000..fadb596db --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java @@ -0,0 +1,260 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateTenantsClient { + private final CollectionDescriptor collection; + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + public WeaviateTenantsClient( + CollectionDescriptor collection, + RestTransport restTransport, + GrpcTransport grpcTransport) { + this.collection = collection; + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + } + + /** + * Add more tenants to the collection. + * + * @param tenants Tenant configurations. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(Tenant... tenants) throws IOException { + create(Arrays.asList(tenants)); + } + + /** + * Add more tenants to the collection. + * + * @param tenants Tenant configurations. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(List tenants) throws IOException { + this.restTransport.performRequest(new CreateTenantsRequest(tenants), CreateTenantsRequest.endpoint(collection)); + } + + /** + * Get tenant information. + * + * @param tenant Tenant name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional get(String tenant) { + var tenants = get(List.of(tenant)); + return tenants.isEmpty() ? Optional.empty() : Optional.ofNullable(tenants.get(0)); + } + + /** + * List all existing tenants. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list() { + return get(); + } + + /** + * List selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List get(String... tenants) { + return get(Arrays.asList(tenants)); + } + + /** + * List selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + */ + public List get(List tenants) { + return this.grpcTransport.performRequest(new GetTenantsRequest(tenants), GetTenantsRequest.rpc(collection)); + } + + /** + * Update tenant configuration. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void update(Tenant... tenants) throws IOException { + update(Arrays.asList(tenants)); + } + + /** + * Update tenant configuration. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void update(List tenants) throws IOException { + this.restTransport.performRequest(new UpdateTenantsRequest(tenants), UpdateTenantsRequest.endpoint(collection)); + } + + /** + * Delete selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(String... tenants) throws IOException { + delete(Arrays.asList(tenants)); + } + + /** + * Delete selected tenants. + * + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(List tenants) throws IOException { + this.restTransport.performRequest(new DeleteTenantsRequest(tenants), DeleteTenantsRequest.endpoint(collection)); + } + + /** + * Check if such tenant exists. + * + * @param tenant Tenant name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean exists(String tenant) throws IOException { + return this.restTransport.performRequest(new TenantExistsRequest(tenant), TenantExistsRequest.endpoint(collection)); + } + + /** + * Activate selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void activate(String... tenants) throws IOException { + activate(Arrays.asList(tenants)); + } + + /** + * Activate selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void activate(List tenants) throws IOException { + update(tenants.stream().map(Tenant::active).toList()); + } + + /** + * Deactivate selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void deactivate(String... tenants) throws IOException { + deactivate(Arrays.asList(tenants)); + } + + /** + * Deactivate selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void deactivate(List tenants) throws IOException { + update(tenants.stream().map(Tenant::inactive).toList()); + } + + /** + * Offload selected tenants. + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void offload(String... tenants) throws IOException { + offload(Arrays.asList(tenants)); + } + + /** + * Offload selected tenants. + * + * + * @param tenants Tenant names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void offload(List tenants) throws IOException { + update(tenants.stream().map(t -> new Tenant(t, TenantStatus.OFFLOADED)).toList()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java new file mode 100644 index 000000000..5725f55ac --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java @@ -0,0 +1,99 @@ +package io.weaviate.client6.v1.api.collections.tenants; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateTenantsClientAsync { + private final CollectionDescriptor collection; + private final RestTransport restTransport; + private final GrpcTransport grpcTransport; + + public WeaviateTenantsClientAsync( + CollectionDescriptor collection, + RestTransport restTransport, + GrpcTransport grpcTransport) { + this.collection = collection; + this.restTransport = restTransport; + this.grpcTransport = grpcTransport; + } + + public CompletableFuture create(Tenant... tenants) throws IOException { + return create(Arrays.asList(tenants)); + } + + public CompletableFuture create(List tenants) throws IOException { + return this.restTransport.performRequestAsync(new CreateTenantsRequest(tenants), + CreateTenantsRequest.endpoint(collection)); + } + + public CompletableFuture> get(String tenant) { + var tenants = get(List.of(tenant)); + return tenants.thenApply(result -> result.isEmpty() ? Optional.empty() : Optional.ofNullable(result.get(0))); + } + + public CompletableFuture> list() { + return get(); + } + + public CompletableFuture> get(String... tenants) { + return get(Arrays.asList(tenants)); + } + + public CompletableFuture> get(List tenants) { + return this.grpcTransport.performRequestAsync(new GetTenantsRequest(tenants), GetTenantsRequest.rpc(collection)); + } + + public CompletableFuture update(Tenant... tenants) throws IOException { + return update(Arrays.asList(tenants)); + } + + public CompletableFuture update(List tenants) throws IOException { + return this.restTransport.performRequestAsync(new UpdateTenantsRequest(tenants), + UpdateTenantsRequest.endpoint(collection)); + } + + public CompletableFuture delete(String... tenants) throws IOException { + return delete(Arrays.asList(tenants)); + } + + public CompletableFuture delete(List tenants) throws IOException { + return this.restTransport.performRequestAsync(new DeleteTenantsRequest(tenants), + DeleteTenantsRequest.endpoint(collection)); + } + + public CompletableFuture exists(String tenant) throws IOException { + return this.restTransport.performRequestAsync(new TenantExistsRequest(tenant), + TenantExistsRequest.endpoint(collection)); + } + + public CompletableFuture activate(String... tenants) throws IOException { + return activate(Arrays.asList(tenants)); + } + + public CompletableFuture activate(List tenants) throws IOException { + return update(tenants.stream().map(Tenant::active).toList()); + } + + public CompletableFuture deactivate(String... tenants) throws IOException { + return deactivate(Arrays.asList(tenants)); + } + + public CompletableFuture deactivate(List tenants) throws IOException { + return update(tenants.stream().map(Tenant::inactive).toList()); + } + + public CompletableFuture offload(String... tenants) throws IOException { + return offload(Arrays.asList(tenants)); + } + + public CompletableFuture offload(List tenants) throws IOException { + return update(tenants.stream().map(t -> new Tenant(t, TenantStatus.OFFLOADED)).toList()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Distance.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Distance.java new file mode 100644 index 000000000..8938327db --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Distance.java @@ -0,0 +1,23 @@ +package io.weaviate.client6.v1.api.collections.vectorindex; + +import com.google.gson.annotations.SerializedName; + +/** + * Distance metrics supported for vector search. + * + * @see Availabe + * distance metrics in Weaviate + */ +public enum Distance { + @SerializedName("cosine") + COSINE, + @SerializedName("dot") + DOT, + @SerializedName("l2-squared") + L2_SQUARED, + @SerializedName("hamming") + HAMMING, + @SerializedName("manhattan") + MANHATTAN; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Dynamic.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Dynamic.java new file mode 100644 index 000000000..63d822674 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Dynamic.java @@ -0,0 +1,120 @@ +package io.weaviate.client6.v1.api.collections.vectorindex; + +import java.io.IOException; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.annotations.SerializedName; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Dynamic( + @SerializedName("hnsw") Hnsw hnsw, + @SerializedName("flat") Flat flat, + @SerializedName("threshold") Long threshold) + implements VectorIndex { + + @Override + public VectorIndex.Kind _kind() { + return VectorIndex.Kind.DYNAMIC; + } + + @Override + public Object _self() { + return this; + } + + public static Dynamic of() { + return of(ObjectBuilder.identity()); + } + + public static Dynamic of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Dynamic(Builder builder) { + this( + builder.hnsw, + builder.flat, + builder.threshold); + } + + public static class Builder implements ObjectBuilder { + + private Hnsw hnsw; + private Flat flat; + private Long threshold; + + public Builder hnsw(Hnsw hnsw) { + this.hnsw = hnsw; + return this; + } + + public Builder flat(Flat flat) { + this.flat = flat; + return this; + } + + public Builder threshold(long threshold) { + this.threshold = threshold; + return this; + } + + @Override + public Dynamic build() { + return new Dynamic(this); + } + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + var rawType = type.getRawType(); + if (!Dynamic.class.isAssignableFrom(rawType)) { + return null; + } + + final var hnswAdapter = gson.getDelegateAdapter(VectorIndex.CustomTypeAdapterFactory.INSTANCE, + TypeToken.get(Hnsw.class)); + final var flatAdapter = gson.getDelegateAdapter(VectorIndex.CustomTypeAdapterFactory.INSTANCE, + TypeToken.get(Flat.class)); + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Dynamic value) throws IOException { + + var dynamic = new JsonObject(); + + dynamic.addProperty("threshold", value.threshold); + dynamic.add("hnsw", hnswAdapter.toJsonTree(value.hnsw)); + dynamic.add("flat", flatAdapter.toJsonTree(value.flat)); + + Streams.write(dynamic, out); + } + + @Override + public Dynamic read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + + var hnsw = hnswAdapter.fromJsonTree(jsonObject.get("hnsw")); + var flat = flatAdapter.fromJsonTree(jsonObject.get("flat")); + var threshold = jsonObject.get("threshold").getAsLong(); + return new Dynamic(hnsw, flat, threshold); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Flat.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Flat.java new file mode 100644 index 000000000..dfa1da185 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Flat.java @@ -0,0 +1,49 @@ +package io.weaviate.client6.v1.api.collections.vectorindex; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Flat(@SerializedName("vectorCacheMaxObjects") Long vectorCacheMaxObjects) + implements VectorIndex { + + @Override + public VectorIndex.Kind _kind() { + return VectorIndex.Kind.FLAT; + } + + @Override + public Object _self() { + return this; + } + + public static Flat of() { + return of(ObjectBuilder.identity()); + } + + public static Flat of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Flat(Builder builder) { + this(builder.vectorCacheMaxObjects); + } + + public static class Builder implements ObjectBuilder { + + private Long vectorCacheMaxObjects; + + public Builder vectorCacheMaxObjects(long vectorCacheMaxObjects) { + this.vectorCacheMaxObjects = vectorCacheMaxObjects; + return this; + } + + @Override + public Flat build() { + return new Flat(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Hnsw.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Hnsw.java new file mode 100644 index 000000000..a6e28ee79 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/Hnsw.java @@ -0,0 +1,154 @@ +package io.weaviate.client6.v1.api.collections.vectorindex; + +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Hnsw( + @SerializedName("distance") Distance distance, + @SerializedName("ef") Integer ef, + @SerializedName("efConstruction") Integer efConstruction, + @SerializedName("maxConnections") Integer maxConnections, + @SerializedName("vectorCacheMaxObjects") Long vectorCacheMaxObjects, + @SerializedName("cleanupIntervalSeconds") Integer cleanupIntervalSeconds, + @SerializedName("filterStrategy") FilterStrategy filterStrategy, + @SerializedName("multivector") MultiVector multiVector, + + @SerializedName("dynamicEfMin") Integer dynamicEfMin, + @SerializedName("dynamicEfMax") Integer dynamicEfMax, + @SerializedName("dynamicEfFactor") Integer dynamicEfFactor, + @SerializedName("flatSearchCutoff") Integer flatSearchCutoff, + @SerializedName("skip") Boolean skipVectorization) implements VectorIndex { + + @Override + public VectorIndex.Kind _kind() { + return VectorIndex.Kind.HNSW; + } + + @Override + public Object _self() { + return this; + } + + public static Hnsw of() { + return of(ObjectBuilder.identity()); + } + + public static Hnsw of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Hnsw(Builder builder) { + this( + builder.distance, + builder.ef, + builder.efConstruction, + builder.maxConnections, + builder.vectorCacheMaxObjects, + builder.cleanupIntervalSeconds, + builder.filterStrategy, + builder.multiVector, + builder.dynamicEfMin, + builder.dynamicEfMax, + builder.dynamicEfFactor, + builder.flatSearchCutoff, + builder.skipVectorization); + } + + public static class Builder implements ObjectBuilder { + private Distance distance; + private Integer ef; + private Integer efConstruction; + private Integer maxConnections; + private Long vectorCacheMaxObjects; + private Integer cleanupIntervalSeconds; + private FilterStrategy filterStrategy; + private MultiVector multiVector; + + private Integer dynamicEfMin; + private Integer dynamicEfMax; + private Integer dynamicEfFactor; + private Integer flatSearchCutoff; + private Boolean skipVectorization; + + public Builder distance(Distance distance) { + this.distance = distance; + return this; + } + + public Builder ef(int ef) { + this.ef = ef; + return this; + } + + public final Builder efConstruction(int efConstruction) { + this.efConstruction = efConstruction; + return this; + } + + public final Builder maxConnections(int maxConnections) { + this.maxConnections = maxConnections; + return this; + } + + public final Builder vectorCacheMaxObjects(long vectorCacheMaxObjects) { + this.vectorCacheMaxObjects = vectorCacheMaxObjects; + return this; + } + + public final Builder cleanupIntervalSeconds(int cleanupIntervalSeconds) { + this.cleanupIntervalSeconds = cleanupIntervalSeconds; + return this; + } + + public final Builder filterStrategy(FilterStrategy filterStrategy) { + this.filterStrategy = filterStrategy; + return this; + } + + public final Builder multiVector(MultiVector multiVector) { + this.multiVector = multiVector; + return this; + } + + public final Builder dynamicEfMin(int dynamicEfMin) { + this.dynamicEfMin = dynamicEfMin; + return this; + } + + public final Builder dynamicEfMax(int dynamicEfMax) { + this.dynamicEfMax = dynamicEfMax; + return this; + } + + public final Builder dynamicEfFactor(int dynamicEfFactor) { + this.dynamicEfFactor = dynamicEfFactor; + return this; + } + + public final Builder flatSearchCutoff(int flatSearchCutoff) { + this.flatSearchCutoff = flatSearchCutoff; + return this; + } + + public final Builder skipVectorization(boolean skip) { + this.skipVectorization = skip; + return this; + } + + @Override + public Hnsw build() { + return new Hnsw(this); + } + } + + public enum FilterStrategy { + @SerializedName("sweeping") + SWEEPING, + @SerializedName("acorn") + ACORN; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/MultiVector.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/MultiVector.java new file mode 100644 index 000000000..2574bffd8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorindex/MultiVector.java @@ -0,0 +1,125 @@ +package io.weaviate.client6.v1.api.collections.vectorindex; + +import java.io.IOException; +import java.util.function.Function; + +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.annotations.SerializedName; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.collections.Encoding; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record MultiVector( + @SerializedName("enabled") boolean enabled, + @SerializedName("aggregation") Aggregation aggregation, + Encoding encoding) { + + public enum Aggregation { + @SerializedName("MAX_SIM") + MAX_SIM; + } + + public static MultiVector of() { + return of(ObjectBuilder.identity()); + } + + public static MultiVector of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public MultiVector(Builder builder) { + this( + builder.enabled, + builder.aggregation, + builder.encoding); + } + + public static class Builder implements ObjectBuilder { + private boolean enabled = true; + private Aggregation aggregation; + private Encoding encoding; + + public Builder enabled(boolean enabled) { + this.enabled = enabled; + return this; + } + + public Builder aggregation(Aggregation aggregation) { + this.aggregation = aggregation; + return this; + } + + public Builder encoding(Encoding encoding) { + this.encoding = encoding; + return this; + } + + @Override + public MultiVector build() { + return new MultiVector(this); + } + } + + public enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + final var rawType = type.getRawType(); + if (!MultiVector.class.isAssignableFrom(rawType)) { + return null; + } + + final TypeAdapter adapter = (TypeAdapter) gson.getDelegateAdapter(this, type); + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, MultiVector value) throws IOException { + var config = adapter.toJsonTree(value); + + if (value.encoding() != null) { + // Replace { "encoding": {...}} with { "muvera": {...}} + // where "muvera" is the kind of encoding configured. + config.getAsJsonObject() + .add(value.encoding()._kind().jsonValue(), + config.getAsJsonObject().remove("encoding")); + } + + Streams.write(config, out); + } + + @Override + public MultiVector read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + + String encodingKind = null; + for (var kind : Encoding.Kind.values()) { + if (jsonObject.has(kind.jsonValue())) { + encodingKind = kind.jsonValue(); + break; + } + } + + if (encodingKind != null) { + JsonObject encoding = new JsonObject(); + encoding.add(encodingKind, jsonObject.remove(encodingKind)); + jsonObject.add("encoding", encoding); + } + + return adapter.fromJsonTree(jsonObject); + } + }.nullSafe(); + } + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Img2VecNeuralVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Img2VecNeuralVectorizer.java new file mode 100644 index 000000000..024f32cb1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Img2VecNeuralVectorizer.java @@ -0,0 +1,83 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Img2VecNeuralVectorizer( + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.IMG2VEC_NEURAL; + } + + @Override + public Object _self() { + return this; + } + + public static Img2VecNeuralVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Img2VecNeuralVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Img2VecNeuralVectorizer(Builder builder) { + this(builder.imageFields, builder.vectorIndex, builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Img2VecNeuralVectorizer build() { + return new Img2VecNeuralVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2MultiVecJinaAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2MultiVecJinaAiVectorizer.java new file mode 100644 index 000000000..93ed9e819 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2MultiVecJinaAiVectorizer.java @@ -0,0 +1,101 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2MultiVecJinaAiVectorizer( + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2MULTIVEC_JINAAI; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2MultiVecJinaAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2MultiVecJinaAiVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2MultiVecJinaAiVectorizer(Builder builder) { + this( + builder.imageFields, + builder.textFields, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List textFields; + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2MultiVecJinaAiVectorizer build() { + return new Multi2MultiVecJinaAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecAwsVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecAwsVectorizer.java new file mode 100644 index 000000000..c7d2b2996 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecAwsVectorizer.java @@ -0,0 +1,188 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecAwsVectorizer( + @SerializedName("model") String model, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("region") String region, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_AWS; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecAwsVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecAwsVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecAwsVectorizer(Builder builder) { + this( + builder.model, + builder.dimensions, + builder.region, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String model; + private Integer dimensions; + private String region; + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder region(String region) { + this.region = region; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecAwsVectorizer build() { + return new Multi2VecAwsVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecBindVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecBindVectorizer.java new file mode 100644 index 000000000..72b13b716 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecBindVectorizer.java @@ -0,0 +1,338 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecBindVectorizer( + /** BLOB image properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** BLOB audio properties included in the embedding. */ + @SerializedName("audioFields") List audioFields, + /** BLOB video properties included in the embedding. */ + @SerializedName("videoFields") List videoFields, + /** BLOB depth properties included in the embedding. */ + @SerializedName("depthFields") List depthFields, + /** BLOB thermal properties included in the embedding. */ + @SerializedName("thermalFields") List thermalFields, + /** BLOB IMU properties included in the embedding. */ + @SerializedName("imuFields") List imuFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB image properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the BLOB audio properties. Values appear in the same order as the + * corresponding property names in {@code audioFields}. + */ + @SerializedName("audioWeights") List audioWeights, + /** + * Weights of the BLOB video properties. Values appear in the same order as the + * corresponding property names in {@code videoFields}. + */ + @SerializedName("videoWeights") List videoWeights, + /** + * Weights of the BLOB depth properties. Values appear in the same order as the + * corresponding property names in {@code depthFields}. + */ + @SerializedName("depthWeights") List depthWeights, + /** + * Weights of the BLOB thermal properties. Values appear in the same order as + * the + * corresponding property names in {@code thermalFields}. + */ + @SerializedName("thermalWeights") List thermalWeights, + /** + * Weights of the BLOB IMU properties. Values appear in the same order as the + * corresponding property names in {@code imuFields}. + */ + @SerializedName("imuWeights") List imuWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_BIND; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecBindVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecBindVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecBindVectorizer( + List imageFields, + List audioFields, + List videoFields, + List depthFields, + List thermalFields, + List imuFields, + List textFields, + Weights weights, + boolean vectorizeCollectionName, + VectorIndex vectorIndex, + Quantization quantization) { + this.vectorizeCollectionName = false; + + this.imageFields = imageFields; + this.audioFields = audioFields; + this.videoFields = videoFields; + this.depthFields = depthFields; + this.thermalFields = thermalFields; + this.imuFields = imuFields; + this.textFields = textFields; + this.weights = weights; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Multi2VecBindVectorizer(Builder builder) { + this( + builder.imageFields.keySet().stream().toList(), + builder.audioFields.keySet().stream().toList(), + builder.videoFields.keySet().stream().toList(), + builder.depthFields.keySet().stream().toList(), + builder.thermalFields.keySet().stream().toList(), + builder.imuFields.keySet().stream().toList(), + builder.textFields.keySet().stream().toList(), + new Weights( + builder.imageFields.values().stream().toList(), + builder.audioFields.values().stream().toList(), + builder.videoFields.values().stream().toList(), + builder.depthFields.values().stream().toList(), + builder.thermalFields.values().stream().toList(), + builder.imuFields.values().stream().toList(), + builder.textFields.values().stream().toList()), + builder.vectorizeCollectionName, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private Map imageFields = new LinkedHashMap<>(); + private Map audioFields = new LinkedHashMap<>(); + private Map videoFields = new LinkedHashMap<>(); + private Map depthFields = new LinkedHashMap<>(); + private Map thermalFields = new LinkedHashMap<>(); + private Map imuFields = new LinkedHashMap<>(); + private Map textFields = new LinkedHashMap<>(); + + /** Add BLOB image properties to include in the embedding. */ + public Builder imageFields(List fields) { + fields.forEach(field -> imageFields.put(field, null)); + return this; + } + + /** Add BLOB image properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB image property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + imageFields.put(field, weight); + return this; + } + + /** Add BLOB audio properties to include in the embedding. */ + public Builder audioFields(List fields) { + fields.forEach(field -> audioFields.put(field, null)); + return this; + } + + /** Add BLOB audio properties to include in the embedding. */ + public Builder audioFields(String... fields) { + return audioFields(Arrays.asList(fields)); + } + + /** + * Add BLOB audio property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder audioField(String field, float weight) { + audioFields.put(field, weight); + return this; + } + + /** Add BLOB video properties to include in the embedding. */ + public Builder videoFields(List fields) { + fields.forEach(field -> videoFields.put(field, null)); + return this; + } + + /** Add BLOB video properties to include in the embedding. */ + public Builder videoFields(String... fields) { + return videoFields(Arrays.asList(fields)); + } + + /** + * Add BLOB video property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder videoField(String field, float weight) { + videoFields.put(field, weight); + return this; + } + + /** Add BLOB depth properties to include in the embedding. */ + public Builder depthFields(List fields) { + fields.forEach(field -> depthFields.put(field, null)); + return this; + } + + /** Add BLOB depth properties to include in the embedding. */ + public Builder depthFields(String... fields) { + return depthFields(Arrays.asList(fields)); + } + + /** + * Add BLOB depth property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder depthField(String field, float weight) { + depthFields.put(field, weight); + return this; + } + + /** Add BLOB thermal properties to include in the embedding. */ + public Builder thermalFields(List fields) { + fields.forEach(field -> thermalFields.put(field, null)); + return this; + } + + /** Add BLOB thermal properties to include in the embedding. */ + public Builder thermalFields(String... fields) { + return thermalFields(Arrays.asList(fields)); + } + + /** + * Add BLOB thermal property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder thermalField(String field, float weight) { + thermalFields.put(field, weight); + return this; + } + + /** Add BLOB IMU properties to include in the embedding. */ + public Builder imuFields(List fields) { + fields.forEach(field -> imuFields.put(field, null)); + return this; + } + + /** Add BLOB IMU properties to include in the embedding. */ + public Builder imuFields(String... fields) { + return imuFields(Arrays.asList(fields)); + } + + /** + * Add BLOB IMU property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imuField(String field, float weight) { + imuFields.put(field, weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + fields.forEach(field -> textFields.put(field, null)); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + textFields.put(field, weight); + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecBindVectorizer build() { + return new Multi2VecBindVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecClipVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecClipVectorizer.java new file mode 100644 index 000000000..2e79a3236 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecClipVectorizer.java @@ -0,0 +1,174 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecClipVectorizer( + /** Base URL of the embedding service. */ + @SerializedName("inferenceUrl") String inferenceUrl, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_CLIP; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecClipVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecClipVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecClipVectorizer(Builder builder) { + this( + builder.inferenceUrl, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String inferenceUrl; + + /** Set base URL of the embedding service. */ + public Builder inferenceUrl(String inferenceUrl) { + this.inferenceUrl = inferenceUrl; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + @Override + public Multi2VecClipVectorizer build() { + return new Multi2VecClipVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecCohereVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecCohereVectorizer.java new file mode 100644 index 000000000..9a572ef06 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecCohereVectorizer.java @@ -0,0 +1,223 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecCohereVectorizer( + /** Base URL of the embedding service. */ + @SerializedName("baseURL") String baseUrl, + /** Inference model to use. */ + @SerializedName("model") String model, + /** The number of dimensions for the generated embeddings. */ + @SerializedName("dimensions") Integer dimensions, + /** The truncate strategy to use. */ + @SerializedName("truncate") String truncate, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_COHERE; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecCohereVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecCohereVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecCohereVectorizer( + String baseUrl, + String model, + Integer dimensions, + String truncate, + List imageFields, + List textFields, + Weights weights, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + this.dimensions = dimensions; + this.truncate = truncate; + this.imageFields = imageFields; + this.textFields = textFields; + this.weights = weights; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Multi2VecCohereVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.dimensions, + builder.truncate, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String baseUrl; + private String model; + private Integer dimensions; + private String truncate; + + /** Set base URL of the embedding service. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(Integer dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder truncate(String truncate) { + this.truncate = truncate; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecCohereVectorizer build() { + return new Multi2VecCohereVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecGoogleVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecGoogleVectorizer.java new file mode 100644 index 000000000..c22b7b4a3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecGoogleVectorizer.java @@ -0,0 +1,267 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecGoogleVectorizer( + @SerializedName("projectId") String projectId, + @SerializedName("model") String model, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("location") String location, + @SerializedName("videoIntervalSeconds") Integer videoIntervalSeconds, + /** BLOB image properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** BLOB video properties included in the embedding. */ + @SerializedName("videoFields") List videoFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB image properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the BLOB video properties. Values appear in the same order as the + * corresponding property names in {@code videoFields}. + */ + @SerializedName("videoWeights") List videoWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_GOOGLE; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecGoogleVectorizer of(String projectId, String location) { + return of(projectId, location, ObjectBuilder.identity()); + } + + public static Multi2VecGoogleVectorizer of( + String projectId, + String location, + Function> fn) { + return fn.apply(new Builder(projectId, location)).build(); + } + + public Multi2VecGoogleVectorizer( + String projectId, + String model, + Integer dimensions, + String location, + Integer videoIntervalSeconds, + List imageFields, + List videoFields, + List textFields, + Weights weights, + VectorIndex vectorIndex, + Quantization quantization) { + + this.projectId = projectId; + this.model = model; + this.dimensions = dimensions; + this.location = location; + this.videoIntervalSeconds = videoIntervalSeconds; + this.imageFields = imageFields; + this.videoFields = videoFields; + this.textFields = textFields; + this.weights = weights; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Multi2VecGoogleVectorizer(Builder builder) { + this( + builder.projectId, + builder.model, + builder.dimensions, + builder.location, + builder.videoIntervalSeconds, + builder.imageFields, + builder.videoFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List videoFields; + private List videoWeights; + private List textFields; + private List textWeights; + + private final String projectId; + private String model; + private String location; + private Integer dimensions; + private Integer videoIntervalSeconds; + + public Builder(String projectId, String location) { + this.projectId = projectId; + this.location = location; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder videoIntervalSeconds(int videoIntervalSeconds) { + this.videoIntervalSeconds = videoIntervalSeconds; + return this; + } + + /** Add BLOB image properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB image properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB image property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add BLOB video properties to include in the embedding. */ + public Builder videoFields(List fields) { + this.videoFields = fields; + return this; + } + + /** Add BLOB video properties to include in the embedding. */ + public Builder videoFields(String... fields) { + return videoFields(Arrays.asList(fields)); + } + + /** + * Add BLOB video property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder videoField(String field, float weight) { + if (this.videoFields == null) { + this.videoFields = new ArrayList<>(); + } + if (this.videoWeights == null) { + this.videoWeights = new ArrayList<>(); + } + this.videoFields.add(field); + this.videoWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null || this.videoWeights != null) { + return new Weights(this.imageWeights, this.videoWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecGoogleVectorizer build() { + return new Multi2VecGoogleVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecJinaAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecJinaAiVectorizer.java new file mode 100644 index 000000000..30f6d0df7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecJinaAiVectorizer.java @@ -0,0 +1,210 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecJinaAiVectorizer( + /** Base URL of the embedding service. */ + @SerializedName("baseURL") String baseUrl, + /** Inference model to use. */ + @SerializedName("model") String model, + @SerializedName("dimensions") Integer dimensions, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_JINAAI; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecJinaAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecJinaAiVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecJinaAiVectorizer( + String baseUrl, + String model, + Integer dimensions, + List imageFields, + List textFields, + Weights weights, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + this.dimensions = dimensions; + this.imageFields = imageFields; + this.textFields = textFields; + this.weights = weights; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Multi2VecJinaAiVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.dimensions, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String baseUrl; + private String model; + private Integer dimensions; + + /** Set base URL of the embedding service. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecJinaAiVectorizer build() { + return new Multi2VecJinaAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecNvidiaVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecNvidiaVectorizer.java new file mode 100644 index 000000000..bf1f662b7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecNvidiaVectorizer.java @@ -0,0 +1,192 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecNvidiaVectorizer( + /** Base URL of the embedding service. */ + @SerializedName("baseURL") String baseUrl, + /** Inference model to use. */ + @SerializedName("model") String model, + /** Whether to apply truncation. */ + @SerializedName("truncate") Boolean truncate, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_NVIDIA; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecNvidiaVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecNvidiaVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecNvidiaVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.truncate, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String baseUrl; + private String model; + private Boolean truncate; + + /** Set base URL of the embedding service. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder truncate(Boolean truncate) { + this.truncate = truncate; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecNvidiaVectorizer build() { + return new Multi2VecNvidiaVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecVoyageAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecVoyageAiVectorizer.java new file mode 100644 index 000000000..2f3da32ee --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Multi2VecVoyageAiVectorizer.java @@ -0,0 +1,211 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Multi2VecVoyageAiVectorizer( + /** Base URL of the embedding service. */ + @SerializedName("baseURL") String baseUrl, + /** Inference model to use. */ + @SerializedName("model") String model, + @SerializedName("truncate") Boolean truncate, + /** BLOB properties included in the embedding. */ + @SerializedName("imageFields") List imageFields, + /** TEXT properties included in the embedding. */ + @SerializedName("textFields") List textFields, + /** Weights of the included properties. */ + @SerializedName("weights") Weights weights, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + private static record Weights( + /** + * Weights of the BLOB properties. Values appear in the same order as the + * corresponding property names in {@code imageFields}. + */ + @SerializedName("imageWeights") List imageWeights, + /** + * Weights of the TEXT properties. Values appear in the same order as the + * corresponding property names in {@code textFields}. + */ + @SerializedName("textWeights") List textWeights) { + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.MULTI2VEC_VOYAGEAI; + } + + @Override + public Object _self() { + return this; + } + + public static Multi2VecVoyageAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Multi2VecVoyageAiVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Multi2VecVoyageAiVectorizer( + String baseUrl, + String model, + Boolean truncate, + List imageFields, + List textFields, + Weights weights, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + this.truncate = truncate; + this.imageFields = imageFields; + this.textFields = textFields; + this.weights = weights; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Multi2VecVoyageAiVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.truncate, + builder.imageFields, + builder.textFields, + builder.getWeights(), + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + private List imageFields; + private List imageWeights; + private List textFields; + private List textWeights; + + private String baseUrl; + private String model; + private Boolean truncate; + + /** Set base URL of the embedding service. */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder truncate(boolean truncate) { + this.truncate = truncate; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(List fields) { + this.imageFields = fields; + return this; + } + + /** Add BLOB properties to include in the embedding. */ + public Builder imageFields(String... fields) { + return imageFields(Arrays.asList(fields)); + } + + /** + * Add BLOB property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder imageField(String field, float weight) { + if (this.imageFields == null) { + this.imageFields = new ArrayList<>(); + } + if (this.imageWeights == null) { + this.imageWeights = new ArrayList<>(); + } + this.imageFields.add(field); + this.imageWeights.add(weight); + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(List fields) { + this.textFields = fields; + return this; + } + + /** Add TEXT properties to include in the embedding. */ + public Builder textFields(String... fields) { + return textFields(Arrays.asList(fields)); + } + + /** + * Add TEXT property to include in the embedding. + * + * @param field Property name. + * @param weight Custom weight between 0.0 and 1.0. + */ + public Builder textField(String field, float weight) { + if (this.textFields == null) { + this.textFields = new ArrayList<>(); + } + if (this.textWeights == null) { + this.textWeights = new ArrayList<>(); + } + this.textFields.add(field); + this.textWeights.add(weight); + return this; + } + + protected Weights getWeights() { + if (this.textWeights != null || this.imageWeights != null) { + return new Weights(this.imageWeights, this.textWeights); + } + return null; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public Multi2VecVoyageAiVectorizer build() { + return new Multi2VecVoyageAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Ref2VecCentroidVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Ref2VecCentroidVectorizer.java new file mode 100644 index 000000000..b018ca1f3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Ref2VecCentroidVectorizer.java @@ -0,0 +1,100 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Ref2VecCentroidVectorizer( + @SerializedName("referenceProperties") List referenceProperties, + @SerializedName("method") Method method, + + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.REF2VEC_CENTROID; + } + + @Override + public Object _self() { + return this; + } + + public enum Method { + @SerializedName("mean") + MEAN; + } + + public static Ref2VecCentroidVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Ref2VecCentroidVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Ref2VecCentroidVectorizer(Builder builder) { + this( + builder.referenceProperties, + builder.method, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private Quantization quantization; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private List referenceProperties = new ArrayList<>(); + private Method method = Method.MEAN; + + /** Add properties to include in the embedding. */ + public Builder referenceProperties(String... properties) { + return referenceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder referenceProperties(List properties) { + this.referenceProperties.addAll(properties); + return this; + } + + public Builder method(Method method) { + this.method = method; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Ref2VecCentroidVectorizer build() { + return new Ref2VecCentroidVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/SelfProvidedVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/SelfProvidedVectorizer.java new file mode 100644 index 000000000..269053fb0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/SelfProvidedVectorizer.java @@ -0,0 +1,56 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.function.Function; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record SelfProvidedVectorizer( + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + @Override + public Kind _kind() { + return VectorConfig.Kind.NONE; + } + + @Override + public Object _self() { + return this; + } + + public static SelfProvidedVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static SelfProvidedVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public SelfProvidedVectorizer(Builder builder) { + this(builder.vectorIndex, builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + @Override + public SelfProvidedVectorizer build() { + return new SelfProvidedVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2MultiVecJinaAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2MultiVecJinaAiVectorizer.java new file mode 100644 index 000000000..4372a426e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2MultiVecJinaAiVectorizer.java @@ -0,0 +1,143 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2MultiVecJinaAiVectorizer( + @SerializedName("model") String model, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("baseURL") String baseUrl, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2MULTIVEC_JINAAI; + } + + @Override + public Object _self() { + return this; + } + + public static Text2MultiVecJinaAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2MultiVecJinaAiVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2MultiVecJinaAiVectorizer( + String model, + Integer dimensions, + String baseUrl, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.model = model; + this.dimensions = dimensions; + this.baseUrl = baseUrl; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2MultiVecJinaAiVectorizer(Builder builder) { + this( + builder.model, + builder.dimensions, + builder.baseUrl, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties = new ArrayList<>(); + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String model; + private Integer dimensions; + private String baseUrl; + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties.addAll(properties); + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2MultiVecJinaAiVectorizer build() { + return new Text2MultiVecJinaAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAwsVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAwsVectorizer.java new file mode 100644 index 000000000..f8cf23629 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAwsVectorizer.java @@ -0,0 +1,220 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecAwsVectorizer( + @SerializedName("endpoint") String endpoint, + @SerializedName("model") String model, + @SerializedName("region") String region, + @SerializedName("service") Service service, + @SerializedName("targetModel") String targetModel, + @SerializedName("targetVariant") String targetVariant, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_AWS; + } + + @Override + public Object _self() { + return this; + } + + public enum Service { + @SerializedName("bedrock") + BEDROCK, + @SerializedName("sagemaker") + SAGEMAKER; + } + + public static final String AMAZON_TITAN_EMBED_TEXT_V1 = "amazon.titan-embed-text-v1"; + public static final String COHERE_EMBED_ENGLISH_V3 = "cohere.embed-english-v3"; + public static final String COHERE_EMBED_MULTILINGUAL_V3 = "cohere.embed-multilingual-v3"; + + public static Text2VecAwsVectorizer bedrock(String model) { + return bedrock(model, ObjectBuilder.identity()); + } + + public static Text2VecAwsVectorizer bedrock( + String model, + Function> fn) { + return fn.apply(new BedrockBuilder(model)).build(); + } + + public static Text2VecAwsVectorizer sagemaker(String endpoint) { + return sagemaker(endpoint, ObjectBuilder.identity()); + } + + public static Text2VecAwsVectorizer sagemaker( + String endpoint, + Function> fn) { + return fn.apply(new SagemakerBuilder(endpoint)).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecAwsVectorizer( + String endpoint, + String model, + String region, + Service service, + String targetModel, + String targetVariant, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.endpoint = endpoint; + this.model = model; + this.region = region; + this.service = service; + this.targetModel = targetModel; + this.targetVariant = targetVariant; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecAwsVectorizer(Builder builder) { + this( + builder.endpoint, + builder.model, + builder.region, + builder.service, + builder.targetModel, + builder.targetVariant, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public abstract static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private final Service service; + private String endpoint; + private String model; + private String region; + private String targetModel; + private String targetVariant; + + protected Builder(Service service) { + this.service = service; + } + + /** Required for {@link Service#SAGEMAKER}. */ + protected Builder endpoint(String endpoint) { + this.endpoint = endpoint; + return this; + } + + /** Required for {@link Service#BEDROCK}. */ + protected Builder model(String model) { + this.model = model; + return this; + } + + public Builder region(String region) { + this.region = region; + return this; + } + + public Builder targetModel(String targetModel) { + this.targetModel = targetModel; + return this; + } + + public Builder targetVariant(String targetVariant) { + this.targetVariant = targetVariant; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecAwsVectorizer build() { + return new Text2VecAwsVectorizer(this); + } + } + + public static class BedrockBuilder extends Builder { + public BedrockBuilder(String model) { + super(Service.BEDROCK); + super.model(model); + } + + @Override + /** Required for {@link Service#BEDROCK}. */ + public Builder model(String model) { + return super.model(model); + } + } + + public static class SagemakerBuilder extends Builder { + public SagemakerBuilder(String endpoint) { + super(Service.SAGEMAKER); + super.endpoint(endpoint); + } + + /** Required for {@link Service#SAGEMAKER}. */ + protected Builder endpoint(String endpoint) { + return super.endpoint(endpoint); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAzureOpenAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAzureOpenAiVectorizer.java new file mode 100644 index 000000000..c0ef4a33a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecAzureOpenAiVectorizer.java @@ -0,0 +1,164 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecAzureOpenAiVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("model") String model, + @SerializedName("deploymentId") String deploymentId, + @SerializedName("resourceName") String resourceName, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_AZURE_OPENAI; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecAzureOpenAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecAzureOpenAiVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecAzureOpenAiVectorizer( + String baseUrl, + Integer dimensions, + String model, + String deploymentId, + String resourceName, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.dimensions = dimensions; + this.model = model; + this.deploymentId = deploymentId; + this.resourceName = resourceName; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecAzureOpenAiVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.dimensions, + builder.model, + builder.deploymentId, + builder.resourceName, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String baseUrl; + private Integer dimensions; + private String model; + private String deploymentId; + private String resourceName; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Set the number of dimensions for the vector embeddings. */ + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + /** Select the embedding model. */ + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder deploymentId(String deploymentId) { + this.deploymentId = deploymentId; + return this; + } + + public Builder resourceName(String resourceName) { + this.resourceName = resourceName; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecAzureOpenAiVectorizer build() { + return new Text2VecAzureOpenAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecCohereVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecCohereVectorizer.java new file mode 100644 index 000000000..9731a2457 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecCohereVectorizer.java @@ -0,0 +1,164 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecCohereVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("truncate") Truncate truncate, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_COHERE; + } + + @Override + public Object _self() { + return this; + } + + public enum Truncate { + @SerializedName("NONE") + NONE, + @SerializedName("START") + START, + @SerializedName("END") + END, + @SerializedName("LEFT") + LEFT, + @SerializedName("RIGHT") + RIGHT; + } + + public static Text2VecCohereVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecCohereVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecCohereVectorizer( + String baseUrl, + String model, + Integer dimensions, + Truncate truncate, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.model = model; + this.dimensions = dimensions; + this.truncate = truncate; + this.baseUrl = baseUrl; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecCohereVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.dimensions, + builder.truncate, + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String model; + private Integer dimensions; + private Truncate truncate; + private String baseUrl; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(Integer dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder truncate(Truncate truncate) { + this.truncate = truncate; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecCohereVectorizer build() { + return new Text2VecCohereVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecDatabricksVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecDatabricksVectorizer.java new file mode 100644 index 000000000..708eb7be4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecDatabricksVectorizer.java @@ -0,0 +1,132 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecDatabricksVectorizer( + @SerializedName("endpoint") String endpoint, + @SerializedName("instruction") String instruction, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_DATABRICKS; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecDatabricksVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecDatabricksVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecDatabricksVectorizer( + String endpoint, + String instruction, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.endpoint = endpoint; + this.instruction = instruction; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecDatabricksVectorizer(Builder builder) { + this( + builder.endpoint, + builder.instruction, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String endpoint; + private String instruction; + + public Builder endpoint(String endpoint) { + this.endpoint = endpoint; + return this; + } + + public Builder instruction(String instruction) { + this.instruction = instruction; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecDatabricksVectorizer build() { + return new Text2VecDatabricksVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecGoogleVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecGoogleVectorizer.java new file mode 100644 index 000000000..1791a0904 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecGoogleVectorizer.java @@ -0,0 +1,224 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecGoogleVectorizer( + @SerializedName("apiEndpoint") String apiEndpoint, + @SerializedName("model") String model, + @SerializedName("titleProperty") String titleProperty, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("taskType") TaskType taskType, + + /** Google project ID. Only relevant for Vertex AI integration. */ + @SerializedName("projectId") String projectId, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + public enum TaskType { + @SerializedName("RETRIEVAL_QUERY") + RETRIEVAL_QUERY, + @SerializedName("CODE_RETRIEVAL_QUERY") + CODE_RETRIEVAL_QUERY, + @SerializedName("QUESTION_ANSWERING") + QUESTION_ANSWERING, + @SerializedName("FACT_VERIFICATION") + FACT_VERIFICATION, + @SerializedName("CLASSIFICATION") + CLASSIFICATION, + @SerializedName("CLUSTERING") + CLUSTERING, + @SerializedName("SEMANTIC_SIMILARITY") + SEMANTIC_SIMILARITY; + } + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_GOOGLE; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecGoogleVectorizer aiStudio() { + return aiStudio(ObjectBuilder.identity()); + } + + public static Text2VecGoogleVectorizer aiStudio( + Function> fn) { + return fn.apply(new AiStudioBuilder()).build(); + } + + public static Text2VecGoogleVectorizer vertex(String projectId) { + return vertex(projectId, ObjectBuilder.identity()); + } + + public static Text2VecGoogleVectorizer vertex( + String projectId, + Function> fn) { + return fn.apply(new VertexBuilder(projectId)).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecGoogleVectorizer( + String apiEndpoint, + String model, + String titleProperty, + Integer dimensions, + TaskType taskType, + String projectId, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.apiEndpoint = apiEndpoint; + this.model = model; + this.titleProperty = titleProperty; + this.dimensions = dimensions; + this.projectId = projectId; + this.taskType = taskType; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecGoogleVectorizer(Builder builder) { + this( + builder.apiEndpoint, + builder.model, + builder.titleProperty, + builder.dimensions, + builder.taskType, + builder.projectId, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public abstract static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + /** Embedding service base URL. */ + private String apiEndpoint; + /** Google project ID. Only relevant for Vertex AI integration. */ + private final String projectId; + + private String model; + private String titleProperty; + private Integer dimensions; + private TaskType taskType; + + public Builder(String apiEndpoint, String projectId) { + this.apiEndpoint = apiEndpoint; + this.projectId = projectId; + } + + protected Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder titleProperty(String titleProperty) { + this.titleProperty = titleProperty; + return this; + } + + public Builder taskType(TaskType taskType) { + this.taskType = taskType; + return this; + } + + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecGoogleVectorizer build() { + return new Text2VecGoogleVectorizer(this); + } + } + + public static class AiStudioBuilder extends Builder { + public static final String BASE_URL = "generativelanguage.googleapis.com"; + + public AiStudioBuilder() { + super(BASE_URL, null); + } + } + + public static class VertexBuilder extends Builder { + public static final String DEFAULT_BASE_URL = "us-central1-aiplatform.googleapis.com"; + + public VertexBuilder(String projectId) { + super(DEFAULT_BASE_URL, projectId); + } + + public VertexBuilder apiEndpoint(String apiEndpoint) { + super.apiEndpoint(apiEndpoint); + return this; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecHuggingFaceVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecHuggingFaceVectorizer.java new file mode 100644 index 000000000..1d3a200d9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecHuggingFaceVectorizer.java @@ -0,0 +1,183 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecHuggingFaceVectorizer( + @SerializedName("endpointURL") String endpointUrl, + @SerializedName("model") String model, + @SerializedName("passageModel") String passageModel, + @SerializedName("queryModel") String queryModel, + @SerializedName("useCache") Boolean useCache, + @SerializedName("useGPU") Boolean useGpu, + @SerializedName("waitForModel") Boolean waitForModel, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_HUGGINGFACE; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecHuggingFaceVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecHuggingFaceVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecHuggingFaceVectorizer( + String endpointUrl, + String model, + String passageModel, + String queryModel, + Boolean useCache, + Boolean useGpu, + Boolean waitForModel, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.endpointUrl = endpointUrl; + this.model = model; + this.passageModel = passageModel; + this.queryModel = queryModel; + this.useCache = useCache; + this.useGpu = useGpu; + this.waitForModel = waitForModel; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecHuggingFaceVectorizer(Builder builder) { + this( + builder.endpointUrl, + builder.model, + builder.passageModel, + builder.queryModel, + builder.useCache, + builder.useGpu, + builder.waitForModel, + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String endpointUrl; + private String model; + private String passageModel; + private String queryModel; + private Boolean useCache; + private Boolean useGpu; + private Boolean waitForModel; + + public Builder endpointUrl(String endpointUrl) { + this.endpointUrl = endpointUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + /** The model to use for passage vectorization. */ + public Builder passageModel(String passageModel) { + this.passageModel = passageModel; + return this; + } + + /** The model to use for query vectorization. */ + public Builder queryModel(String queryModel) { + this.queryModel = queryModel; + return this; + } + + public Builder useCache(boolean useCache) { + this.useCache = useCache; + return this; + } + + public Builder useGpu(boolean useGpu) { + this.useGpu = useGpu; + return this; + } + + public Builder waitForModel(boolean waitForModel) { + this.waitForModel = waitForModel; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecHuggingFaceVectorizer build() { + return new Text2VecHuggingFaceVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecJinaAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecJinaAiVectorizer.java new file mode 100644 index 000000000..a13fa6287 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecJinaAiVectorizer.java @@ -0,0 +1,145 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecJinaAiVectorizer( + @SerializedName("model") String model, + @SerializedName("baseURL") String baseUrl, + @SerializedName("dimensions") Integer dimensions, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_JINAAI; + } + + @Override + public Object _self() { + return this; + } + + public static String JINA_EMBEDDINGS_V2_BASE_EN = "jina-embeddings-v2-base-en"; + public static String JINA_EMBEDDINGS_V2_SMALL_EN = "jina-embeddings-v2-small-en"; + + public static Text2VecJinaAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecJinaAiVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecJinaAiVectorizer( + String model, + String baseUrl, + Integer dimensions, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.model = model; + this.baseUrl = baseUrl; + this.dimensions = dimensions; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecJinaAiVectorizer(Builder builder) { + this( + builder.model, + builder.baseUrl, + builder.dimensions, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String model; + private Integer dimensions; + private String baseUrl; + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecJinaAiVectorizer build() { + return new Text2VecJinaAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMistralVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMistralVectorizer.java new file mode 100644 index 000000000..14bdd5b01 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMistralVectorizer.java @@ -0,0 +1,134 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecMistralVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_MISTRAL; + } + + @Override + public Object _self() { + return this; + } + + public static String MISTRAL_EMBED = "mistral-embed"; + + public static Text2VecMistralVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecMistralVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecMistralVectorizer( + String baseUrl, + String model, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecMistralVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String baseUrl; + private String model; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecMistralVectorizer build() { + return new Text2VecMistralVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecModel2VecVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecModel2VecVectorizer.java new file mode 100644 index 000000000..fbda7a44b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecModel2VecVectorizer.java @@ -0,0 +1,121 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecModel2VecVectorizer( + @SerializedName("inferenceURL") String inferenceUrl, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_MODEL2VEC; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecModel2VecVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecModel2VecVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecModel2VecVectorizer( + String inferenceUrl, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.inferenceUrl = inferenceUrl; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecModel2VecVectorizer(Builder builder) { + this( + builder.inferenceUrl, + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String inferenceUrl; + + public Builder inferenceUrl(String inferenceUrl) { + this.inferenceUrl = inferenceUrl; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecModel2VecVectorizer build() { + return new Text2VecModel2VecVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMorphVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMorphVectorizer.java new file mode 100644 index 000000000..7dfd31f8a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecMorphVectorizer.java @@ -0,0 +1,103 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecMorphVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_MORPH; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecMorphVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecMorphVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Text2VecMorphVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String baseUrl; + private String model; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecMorphVectorizer build() { + return new Text2VecMorphVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecNvidiaVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecNvidiaVectorizer.java new file mode 100644 index 000000000..f33e46a59 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecNvidiaVectorizer.java @@ -0,0 +1,142 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecNvidiaVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("truncate") Boolean truncate, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_NVIDIA; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecNvidiaVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecNvidiaVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecNvidiaVectorizer( + String baseUrl, + String model, + Boolean truncate, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + this.truncate = truncate; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecNvidiaVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.truncate, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String baseUrl; + private String model; + private Boolean truncate; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder truncate(Boolean truncate) { + this.truncate = truncate; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecNvidiaVectorizer build() { + return new Text2VecNvidiaVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOllamaVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOllamaVectorizer.java new file mode 100644 index 000000000..10718769b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOllamaVectorizer.java @@ -0,0 +1,132 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecOllamaVectorizer( + @SerializedName("apiEndpoint") String apiEndpoint, + @SerializedName("model") String model, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_OLLAMA; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecOllamaVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecOllamaVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecOllamaVectorizer( + String apiEndpoint, + String model, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.apiEndpoint = apiEndpoint; + this.model = model; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecOllamaVectorizer(Builder builder) { + this( + builder.apiEndpoint, + builder.model, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String apiEndpoint; + private String model; + + public Builder apiEndpoint(String apiEndpoint) { + this.apiEndpoint = apiEndpoint; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecOllamaVectorizer build() { + return new Text2VecOllamaVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOpenAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOpenAiVectorizer.java new file mode 100644 index 000000000..60667d0c6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecOpenAiVectorizer.java @@ -0,0 +1,173 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecOpenAiVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("modelVersion") String modelVersion, + @SerializedName("dimensions") Integer dimensions, + @SerializedName("type") ModelType modelType, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_OPENAI; + } + + public static String TEXT_EMBEDDING_3_SMALL = "text-embedding-3-small"; + public static String TEXT_EMBEDDING_3_LARGE = "text-embedding-3-large"; + public static String TEXT_EMBEDDING_ADA_002 = "text-embedding-ada-002"; + + @Override + public Object _self() { + return this; + } + + public enum ModelType { + @SerializedName("CODE") + CODE, + @SerializedName("TEXT") + TEXT; + } + + public static Text2VecOpenAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecOpenAiVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecOpenAiVectorizer( + String baseUrl, + String model, + String modelVersion, + Integer dimensions, + ModelType modelType, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.baseUrl = baseUrl; + this.model = model; + this.modelVersion = modelVersion; + this.dimensions = dimensions; + this.modelType = modelType; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecOpenAiVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.modelVersion, + builder.dimensions, + builder.modelType, + + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String baseUrl; + private String model; + private String modelVersion; + private Integer dimensions; + private ModelType modelType; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + public Builder modelVersion(String modelVersion) { + this.modelVersion = modelVersion; + return this; + } + + public Builder modelType(ModelType modelType) { + this.modelType = modelType; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecOpenAiVectorizer build() { + return new Text2VecOpenAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecTransformersVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecTransformersVectorizer.java new file mode 100644 index 000000000..3ff04baea --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecTransformersVectorizer.java @@ -0,0 +1,134 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecTransformersVectorizer( + @SerializedName("inferenceUrl") String inferenceUrl, + @SerializedName("passageInferenceUrl") String passageInferenceUrl, + @SerializedName("queryInferenceUrl") String queryInferenceUrl, + @SerializedName("poolingStrategy") PoolingStrategy poolingStrategy, + @SerializedName("dimensions") Integer dimensions, + + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_TRANSFORMERS; + } + + @Override + public Object _self() { + return this; + } + + public enum PoolingStrategy { + @SerializedName("MASKED_MEAN") + MASKED_MEAN, + @SerializedName("CLS") + CLS; + } + + public static Text2VecTransformersVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecTransformersVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Text2VecTransformersVectorizer(Builder builder) { + this( + builder.inferenceUrl, + builder.passageInferenceUrl, + builder.queryInferenceUrl, + builder.poolingStrategy, + builder.dimensions, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String inferenceUrl; + private String passageInferenceUrl; + private String queryInferenceUrl; + private PoolingStrategy poolingStrategy; + private Integer dimensions; + + public Builder inferenceUrl(String inferenceUrl) { + this.inferenceUrl = inferenceUrl; + return this; + } + + public Builder passageInferenceUrl(String passageInferenceUrl) { + this.passageInferenceUrl = passageInferenceUrl; + return this; + } + + public Builder queryInferenceUrl(String queryInferenceUrl) { + this.queryInferenceUrl = queryInferenceUrl; + return this; + } + + public Builder poolingStrategy(PoolingStrategy poolingStrategy) { + this.poolingStrategy = poolingStrategy; + return this; + } + + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecTransformersVectorizer build() { + return new Text2VecTransformersVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecVoyageAiVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecVoyageAiVectorizer.java new file mode 100644 index 000000000..94fda7205 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecVoyageAiVectorizer.java @@ -0,0 +1,158 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecVoyageAiVectorizer( + @SerializedName("baseURL") String baseUrl, + @SerializedName("model") String model, + @SerializedName("truncate") Boolean truncate, + @SerializedName("dimensions") Integer dimensions, + + /** + * Weaviate defaults to {@code true} if the value is not provided. + * To avoid that we send "vectorizeClassName": false all the time + * and make it impossible to enable this feature, as it is deprecated. + */ + @Deprecated @SerializedName("vectorizeClassName") boolean vectorizeCollectionName, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_VOYAGEAI; + } + + @Override + public Object _self() { + return this; + } + + public static String VOYAGE_3_LARGE = "voyage-3-large"; + public static String VOYAGE_3_5 = "voyage-3.5"; + public static String VOYAGE_3_5_lite = "voyage-3.5-lite"; + public static String VOYAGE_3 = "voyage-3"; + public static String VOYAGE_3_LITE = "voyage-3-lite"; + public static String VOYAGE_CONTEXT_3 = "voyage-context-3"; + + public static Text2VecVoyageAiVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecVoyageAiVectorizer of( + Function> fn) { + return fn.apply(new Builder()).build(); + } + + /** + * Canonical constructor always sets {@link #vectorizeCollectionName} to false. + */ + public Text2VecVoyageAiVectorizer( + String baseUrl, + String model, + Boolean truncate, + Integer dimensions, + + boolean vectorizeCollectionName, + List sourceProperties, + VectorIndex vectorIndex, + Quantization quantization) { + this.model = model; + this.truncate = truncate; + this.baseUrl = baseUrl; + this.dimensions = dimensions; + + this.vectorizeCollectionName = false; + this.sourceProperties = sourceProperties; + this.vectorIndex = vectorIndex; + this.quantization = quantization; + } + + public Text2VecVoyageAiVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.model, + builder.truncate, + builder.dimensions, + builder.vectorizeCollectionName, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static class Builder implements ObjectBuilder { + private final boolean vectorizeCollectionName = false; + private Quantization quantization; + private List sourceProperties; + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + + private String model; + private Boolean truncate; + private String baseUrl; + private Integer dimensions; + + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + public Builder model(String model) { + this.model = model; + return this; + } + + public Builder truncate(boolean truncate) { + this.truncate = truncate; + return this; + } + + public Builder dimensions(Integer dimensions) { + this.dimensions = dimensions; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecVoyageAiVectorizer build() { + return new Text2VecVoyageAiVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecWeaviateVectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecWeaviateVectorizer.java new file mode 100644 index 000000000..c08d53479 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/collections/vectorizers/Text2VecWeaviateVectorizer.java @@ -0,0 +1,126 @@ +package io.weaviate.client6.v1.api.collections.vectorizers; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.VectorIndex; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public record Text2VecWeaviateVectorizer( + /** Weaviate Embeddings Service base URL. */ + @SerializedName("baseURL") String baseUrl, + /** Dimensionality of the generated vectors. */ + @SerializedName("dimensions") Integer dimensions, + /** Embedding model. */ + @SerializedName("model") String model, + /** Properties included in the embedding. */ + @SerializedName("properties") List sourceProperties, + /** Vector index configuration. */ + VectorIndex vectorIndex, + /** Vector quantization method. */ + Quantization quantization) implements VectorConfig { + + @Override + public VectorConfig.Kind _kind() { + return VectorConfig.Kind.TEXT2VEC_WEAVIATE; + } + + @Override + public Object _self() { + return this; + } + + public static Text2VecWeaviateVectorizer of() { + return of(ObjectBuilder.identity()); + } + + public static Text2VecWeaviateVectorizer of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public Text2VecWeaviateVectorizer(Builder builder) { + this( + builder.baseUrl, + builder.dimensions, + builder.model, + builder.sourceProperties, + builder.vectorIndex, + builder.quantization); + } + + public static final String SNOWFLAKE_ARCTIC_EMBED_M_15 = "Snowflake/snowflake-arctic-embed-m-v1.5"; + public static final String SNOWFLAKE_ARCTIC_EMBED_L_20 = "Snowflake/snowflake-arctic-embed-l-v2.0"; + + public static class Builder implements ObjectBuilder { + private VectorIndex vectorIndex = VectorIndex.DEFAULT_VECTOR_INDEX; + private Quantization quantization; + private String baseUrl; + private Integer dimensions; + private String model; + private List sourceProperties; + + /** + * Base URL for Weaviate Embeddings Service. This can be omitted when connecting + * to a Weaviate Cloud instance: the client will automatically set the necessary + * headers. + */ + public Builder baseUrl(String baseUrl) { + this.baseUrl = baseUrl; + return this; + } + + /** Set target dimensionality for generated embeddings. */ + public Builder dimensions(int dimensions) { + this.dimensions = dimensions; + return this; + } + + /** + * Select the embedding model. + * + * @see Text2VecWeaviateVectorizer#SNOWFLAKE_ARCTIC_EMBED_M_15 + * @see Text2VecWeaviateVectorizer#SNOWFLAKE_ARCTIC_EMBED_L_20 + */ + public Builder model(String model) { + this.model = model; + return this; + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(String... properties) { + return sourceProperties(Arrays.asList(properties)); + } + + /** Add properties to include in the embedding. */ + public Builder sourceProperties(List properties) { + this.sourceProperties = properties; + return this; + } + + /** + * Override default vector index configuration. + * + * HNSW + * is the default vector index. + */ + public Builder vectorIndex(VectorIndex vectorIndex) { + this.vectorIndex = vectorIndex; + return this; + } + + public Builder quantization(Quantization quantization) { + this.quantization = quantization; + return this; + } + + public Text2VecWeaviateVectorizer build() { + return new Text2VecWeaviateVectorizer(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/AliasesPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/AliasesPermission.java new file mode 100644 index 000000000..1e5d03b04 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/AliasesPermission.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record AliasesPermission( + @SerializedName("alias") String alias, + @SerializedName("collection") String collection, + @SerializedName("actions") List actions) implements Permission { + + public AliasesPermission(String alias, String collection, Action... actions) { + this(alias, collection, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.ALIASES; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_aliases") + CREATE("create_aliases"), + @SerializedName("read_aliases") + READ("read_aliases"), + @SerializedName("update_aliases") + UPDATE("update_aliases"), + @SerializedName("delete_aliases") + DELETE("delete_aliases"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/BackupsPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/BackupsPermission.java new file mode 100644 index 000000000..b2cd93de0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/BackupsPermission.java @@ -0,0 +1,41 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record BackupsPermission( + @SerializedName("collection") String collection, + @SerializedName("actions") List actions) implements Permission { + + public BackupsPermission(String collection, Action... actions) { + this(collection, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.BACKUPS; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("manage_backups") + MANAGE("manage_backups"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/ClusterPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/ClusterPermission.java new file mode 100644 index 000000000..5d6c3e20b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/ClusterPermission.java @@ -0,0 +1,40 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ClusterPermission( + @SerializedName("actions") List actions) implements Permission { + + public ClusterPermission(Action... actions) { + this(Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.CLUSTER; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("read_cluster") + READ("read_cluster"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/CollectionsPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/CollectionsPermission.java new file mode 100644 index 000000000..f9d6a96d0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/CollectionsPermission.java @@ -0,0 +1,47 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record CollectionsPermission( + @SerializedName("collection") String collection, + @SerializedName("actions") List actions) implements Permission { + + public CollectionsPermission(String collection, Action... actions) { + this(collection, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.COLLECTIONS; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_collections") + CREATE("create_collections"), + @SerializedName("read_collections") + READ("read_collections"), + @SerializedName("update_collections") + UPDATE("update_collections"), + @SerializedName("delete_collections") + DELETE("delete_collections"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/DataPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/DataPermission.java new file mode 100644 index 000000000..f6b0dfd9e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/DataPermission.java @@ -0,0 +1,60 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record DataPermission( + @SerializedName("collection") String collection, + @SerializedName("actions") List actions) implements Permission { + + public DataPermission(String collection, Action... actions) { + this(collection, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.DATA; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_data") + CREATE("create_data"), + @SerializedName("read_data") + READ("read_data"), + @SerializedName("update_data") + UPDATE("update_data"), + @SerializedName("delete_data") + DELETE("delete_data"), + /* + * DO NOT CREATE NEW PERMISSIONS WITH THIS ACTION. + * It is preserved for backward compatibility with 1.28 + * and should only be used internally to read legacy permissions. + */ + @SerializedName("manage_data") + @Deprecated + MANAGE("manage_data") { + @Override + public boolean isDeprecated() { + return true; + }; + }; + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/GroupsPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/GroupsPermission.java new file mode 100644 index 000000000..182ff8091 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/GroupsPermission.java @@ -0,0 +1,46 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.groups.GroupType; + +public record GroupsPermission( + @SerializedName("group") String groupId, + @SerializedName("groupType") GroupType groupType, + @SerializedName("actions") List actions) implements Permission { + + public GroupsPermission(String groupId, GroupType groupType, Action... actions) { + this(groupId, groupType, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.GROUPS; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("read_groups") + READ("read_groups"), + @SerializedName("assign_and_revoke_groups") + ASSIGN_AND_REVOKE("assign_and_revoke_groups"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/NodesPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/NodesPermission.java new file mode 100644 index 000000000..2607f19b5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/NodesPermission.java @@ -0,0 +1,44 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.cluster.NodeVerbosity; + +public record NodesPermission( + @SerializedName("collection") String collection, + @SerializedName("verbosity") NodeVerbosity verbosity, + @SerializedName("actions") List actions) implements Permission { + + public NodesPermission(String collection, NodeVerbosity verbosity, Action... actions) { + this(collection, verbosity, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.NODES; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("read_nodes") + READ("read_nodes"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/Permission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/Permission.java new file mode 100644 index 000000000..9374c4e35 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/Permission.java @@ -0,0 +1,302 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.io.IOException; +import java.util.EnumMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.builder.HashCodeBuilder; + +import com.google.gson.Gson; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.internal.Streams; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import io.weaviate.client6.v1.api.cluster.NodeVerbosity; +import io.weaviate.client6.v1.api.rbac.RolesPermission.Scope; +import io.weaviate.client6.v1.api.rbac.groups.GroupType; +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface Permission { + List> actions(); + + enum Kind implements JsonEnum { + ALIASES("aliases"), + BACKUPS("backups"), + COLLECTIONS("collections"), + DATA("data"), + GROUPS("groups"), + ROLES("roles"), + NODES("nodes"), + TENANTS("tenants"), + REPLICATE("replicate"), + USERS("users"), + + // Fake permission kinds: Weaviate does not use those. + CLUSTER("cluster"); + + private static final Map jsonValueMap = JsonEnum.collectNames(Kind.values()); + private final String jsonValue; + + private Kind(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + + public static Kind valueOfJson(String jsonValue) { + return JsonEnum.valueOfJson(jsonValue, jsonValueMap, Kind.class); + } + } + + Permission.Kind _kind(); + + Object self(); + + /** + * Create {@link AliasesPermission} for an alias. + */ + public static AliasesPermission aliases(String alias, String collection, AliasesPermission.Action... actions) { + checkDeprecation(actions); + return new AliasesPermission(alias, collection, actions); + } + + /** + * Create {@link BackupsPermission} for a collection. + */ + public static BackupsPermission backups(String collection, BackupsPermission.Action... actions) { + checkDeprecation(actions); + return new BackupsPermission(collection, actions); + } + + /** + * Create {@link ClusterPermission} permission. + */ + public static ClusterPermission cluster(ClusterPermission.Action... actions) { + checkDeprecation(actions); + return new ClusterPermission(actions); + } + + /** + * Create permission for collection's configuration. + */ + public static CollectionsPermission collections(String collection, CollectionsPermission.Action... actions) { + checkDeprecation(actions); + return new CollectionsPermission(collection, actions); + } + + /** + * Create permissions for managing collection's data. + */ + public static DataPermission data(String collection, DataPermission.Action... actions) { + checkDeprecation(actions); + return new DataPermission(collection, actions); + } + + /** + * Create permissions for managing RBAC groups. + */ + public static GroupsPermission groups(String groupId, GroupType groupType, GroupsPermission.Action... actions) { + checkDeprecation(actions); + return new GroupsPermission(groupId, groupType, actions); + } + + /** + * Create {@link NodesPermission} scoped to all collections. + */ + public static NodesPermission nodes(NodeVerbosity verbosity, NodesPermission.Action... actions) { + checkDeprecation(actions); + return new NodesPermission("*", verbosity, actions); + } + + /** + * Create {@link NodesPermission} scoped to a specific collection. Verbosity is + * set to {@link NodeVerbosity#VERBOSE} by default. + */ + public static NodesPermission nodes(String collection, NodesPermission.Action... actions) { + checkDeprecation(actions); + return new NodesPermission(collection, NodeVerbosity.VERBOSE, actions); + } + + /** + * Create {@link RolesPermission} for multiple actions. + */ + public static RolesPermission roles(String roleName, Scope scope, RolesPermission.Action... actions) { + checkDeprecation(actions); + return new RolesPermission(roleName, scope, actions); + } + + /** + * Create {@link TenantsPermission} for a tenant. + */ + public static TenantsPermission tenants(String collection, String tenant, TenantsPermission.Action... actions) { + checkDeprecation(actions); + return new TenantsPermission(collection, tenant, actions); + } + + /** + * Create {@link UsersPermission}. + */ + public static UsersPermission users(String userId, UsersPermission.Action... actions) { + checkDeprecation(actions); + return new UsersPermission(userId, actions); + } + + /** + * Create {@link ReplicatePermission}. + * + *

+ * Example: + * {@code Permissions.replicate("Pizza", "shard-123", ReplicatePermission.Action.CREATE)} + */ + public static ReplicatePermission replicate(String collection, String shard, ReplicatePermission.Action... actions) { + checkDeprecation(actions); + return new ReplicatePermission(collection, shard, actions); + } + + private static void checkDeprecation(RbacAction... actions) throws IllegalArgumentException { + for (var action : actions) { + if (action.isDeprecated()) { + throw new IllegalArgumentException(action.jsonValue() + + " is hard-deprecated and should only be used to read legacy permissions created in v1.28"); + } + } + } + + @SuppressWarnings("unchecked") + static List merge(List permissions) { + record Key( + /** + * hash is computed on all permission fields apart from "actions" + * which is what we need to aggregate. + */ + int hash, + /** + * Permission types which do not have any filters differentiate by their class. + */ + Class cls) { + private Key(Object object) { + this(HashCodeBuilder.reflectionHashCode(object, "actions"), object.getClass()); + } + } + + var result = new LinkedHashMap(); // preserve insertion order + for (Permission perm : permissions) { + var key = new Key(perm); + var stored = result.putIfAbsent(key, perm); + if (stored != null) { // A permission for this key already exists, add all actions. + assert stored.actions() != null : "actions == null for " + stored.getClass(); + ((List>) stored.actions()).addAll(perm.actions()); + } + } + return result.values().stream().collect(Collectors.toList()); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + private static final EnumMap> readAdapters = new EnumMap<>( + Permission.Kind.class); + + private final void addAdapter(Gson gson, Permission.Kind kind, Class cls) { + readAdapters.put(kind, (TypeAdapter) gson.getDelegateAdapter(this, TypeToken.get(cls))); + } + + private final void init(Gson gson) { + addAdapter(gson, Permission.Kind.ALIASES, AliasesPermission.class); + addAdapter(gson, Permission.Kind.BACKUPS, BackupsPermission.class); + addAdapter(gson, Permission.Kind.COLLECTIONS, CollectionsPermission.class); + addAdapter(gson, Permission.Kind.DATA, DataPermission.class); + addAdapter(gson, Permission.Kind.GROUPS, GroupsPermission.class); + addAdapter(gson, Permission.Kind.ROLES, RolesPermission.class); + addAdapter(gson, Permission.Kind.NODES, NodesPermission.class); + addAdapter(gson, Permission.Kind.TENANTS, TenantsPermission.class); + addAdapter(gson, Permission.Kind.REPLICATE, ReplicatePermission.class); + addAdapter(gson, Permission.Kind.USERS, UsersPermission.class); + addAdapter(gson, Permission.Kind.CLUSTER, ClusterPermission.class); + } + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + var rawType = type.getRawType(); + if (!Permission.class.isAssignableFrom(rawType)) { + return null; + } + + if (readAdapters.isEmpty()) { + init(gson); + } + + final var writeAdapter = gson.getDelegateAdapter(this, TypeToken.get(rawType)); + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, Permission value) throws IOException { + for (RbacAction action : value.actions()) { + out.beginObject(); + // User might not have provided many actions by mistake + out.name("action"); + out.value(action.jsonValue()); + + if (value.self() != null) { + var permission = writeAdapter.toJsonTree((T) value.self()); + permission.getAsJsonObject().remove("actions"); + + // Some permission types do not have a body + if (!permission.getAsJsonObject().keySet().isEmpty()) { + out.name(value._kind().jsonValue()); + Streams.write(permission, out); + } + } + out.endObject(); + } + } + + @Override + public Permission read(JsonReader in) throws IOException { + var jsonObject = JsonParser.parseReader(in).getAsJsonObject(); + + var actions = new JsonArray(1); + var permission = new JsonObject(); + + var action = jsonObject.remove("action"); + actions.add(action); + + Permission.Kind kind; + if (!jsonObject.keySet().isEmpty()) { + var kindString = jsonObject.keySet().iterator().next(); + kind = Permission.Kind.valueOfJson(kindString); + permission = jsonObject.get(kindString).getAsJsonObject(); + } else { + var actionString = action.getAsString(); + if (actionString.endsWith("_cluster")) { + kind = Permission.Kind.CLUSTER; + } else { + throw new IllegalArgumentException("unknown RBAC action " + actionString); + } + } + + var readAdapter = readAdapters.get(kind); + if (readAdapter == null) { + return null; + } + + permission.add("actions", actions); + return readAdapter.fromJsonTree(permission); + } + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/RbacAction.java b/src/main/java/io/weaviate/client6/v1/api/rbac/RbacAction.java new file mode 100644 index 000000000..1d6476147 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/RbacAction.java @@ -0,0 +1,42 @@ +package io.weaviate.client6.v1.api.rbac; + +import io.weaviate.client6.v1.internal.json.JsonEnum; + +public interface RbacAction> extends JsonEnum { + + /** + * Returns true if the action is hard deprecated. + * + *

+ * Override default return for a deprecated enum value like so: + * + *

{@code
+   * OLD_ACTION("old_action") {
+   *  {@literal @Override}
+   *  public boolean isDeprecated() { return true; }
+   * };
+   * }
+ */ + default boolean isDeprecated() { + return false; + } + + static >> E fromString(Class enumClass, String value) + throws IllegalArgumentException { + for (E action : enumClass.getEnumConstants()) { + if (action.jsonValue().equals(value)) { + return action; + } + } + throw new IllegalArgumentException("No enum constant for value: " + value); + } + + static >> boolean isValid(Class enumClass, String value) { + for (var action : enumClass.getEnumConstants()) { + if (action.jsonValue().equals(value)) { + return true; + } + } + return false; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/ReplicatePermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/ReplicatePermission.java new file mode 100644 index 000000000..aea5bd867 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/ReplicatePermission.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record ReplicatePermission( + @SerializedName("collection") String collection, + @SerializedName("shard") String shard, + @SerializedName("actions") List actions) implements Permission { + + public ReplicatePermission(String collection, String shard, Action... actions) { + this(collection, shard, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.REPLICATE; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_replicate") + CREATE("create_replicate"), + @SerializedName("read_replicate") + READ("read_replicate"), + @SerializedName("update_replicate") + UPDATE("update_replicate"), + @SerializedName("delete_replicate") + DELETE("delete_replicate"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/Role.java b/src/main/java/io/weaviate/client6/v1/api/rbac/Role.java new file mode 100644 index 000000000..3451e83b9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/Role.java @@ -0,0 +1,51 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; + +import com.google.gson.Gson; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.annotations.SerializedName; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +public record Role( + @SerializedName("name") String name, + @SerializedName("permissions") List permissions) { + + public Role(String name, Permission... permissions) { + this(name, Arrays.asList(permissions)); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + if (!Role.class.isAssignableFrom(type.getRawType())) { + return null; + } + var delegate = gson.getDelegateAdapter(this, type); + return new TypeAdapter() { + + @Override + public void write(JsonWriter out, T value) throws IOException { + delegate.write(out, value); + } + + @SuppressWarnings("unchecked") + @Override + public T read(JsonReader in) throws IOException { + var role = (Role) delegate.read(in); + if (role.permissions == null) { + return (T) role; + } + return (T) new Role(role.name(), Permission.merge(role.permissions)); + } + }; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/RolesPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/RolesPermission.java new file mode 100644 index 000000000..ffa779e18 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/RolesPermission.java @@ -0,0 +1,69 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record RolesPermission( + @SerializedName("role") String role, + @SerializedName("scope") Scope scope, + @SerializedName("actions") List actions) implements Permission { + + public RolesPermission(String roleName, Scope scope, Action... actions) { + this(roleName, scope, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.ROLES; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_roles") + CREATE("create_roles"), + @SerializedName("read_roles") + READ("read_roles"), + @SerializedName("update_roles") + UPDATE("update_roles"), + @SerializedName("delete_roles") + DELETE("delete_roles"), + + /* + * DO NOT CREATE NEW PERMISSIONS WITH THIS ACTION. + * It is preserved for backward compatibility with 1.28 + * and should only be used internally to read legacy permissions. + */ + @SerializedName("manage_roles") + @Deprecated + MANAGE("manage_roles") { + @Override + public boolean isDeprecated() { + return true; + }; + }; + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } + + public enum Scope { + @SerializedName("all") + ALL, + @SerializedName("match") + MATCH; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/TenantsPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/TenantsPermission.java new file mode 100644 index 000000000..1c5c3b7d7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/TenantsPermission.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record TenantsPermission( + @SerializedName("collection") String collection, + @SerializedName("tenant") String tenant, + @SerializedName("actions") List actions) implements Permission { + + public TenantsPermission(String collection, String tenant, Action... actions) { + this(collection, tenant, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.TENANTS; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_tenants") + CREATE("create_tenants"), + @SerializedName("read_tenants") + READ("read_tenants"), + @SerializedName("update_tenants") + UPDATE("update_tenants"), + @SerializedName("delete_tenants") + DELETE("delete_tenants"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/UsersPermission.java b/src/main/java/io/weaviate/client6/v1/api/rbac/UsersPermission.java new file mode 100644 index 000000000..43376297c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/UsersPermission.java @@ -0,0 +1,49 @@ +package io.weaviate.client6.v1.api.rbac; + +import java.util.Arrays; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record UsersPermission( + @SerializedName("users") String userId, + @SerializedName("actions") List actions) implements Permission { + + public UsersPermission(String userId, Action... actions) { + this(userId, Arrays.asList(actions)); + } + + @Override + public Permission.Kind _kind() { + return Permission.Kind.USERS; + } + + @Override + public Object self() { + return this; + } + + public enum Action implements RbacAction { + @SerializedName("create_users") + CREATE("create_users"), + @SerializedName("update_users") + UPDATE("update_users"), + @SerializedName("read_users") + READ("read_users"), + @SerializedName("delete_users") + DELETE("delete_users"), + @SerializedName("assign_and_revoke_users") + ASSIGN_AND_REVOKE("assign_and_revoke_users"); + + private final String jsonValue; + + private Action(String jsonValue) { + this.jsonValue = jsonValue; + } + + @Override + public String jsonValue() { + return jsonValue; + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/AssignRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/AssignRolesRequest.java new file mode 100644 index 000000000..0b04a311b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/AssignRolesRequest.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record AssignRolesRequest(String groupId, List roleNames) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/groups/" + UrlEncoder.encodeValue(request.groupId) + "/assign", + request -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.roleNames, GroupType.OIDC))); + + /** Request body should be {"roles": [...], "groupType": "oidc"} */ + private static record Body( + @SerializedName("roles") List roleNames, + @SerializedName("groupType") GroupType groupType) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetAssignedRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetAssignedRolesRequest.java new file mode 100644 index 000000000..8a6b7443e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetAssignedRolesRequest.java @@ -0,0 +1,59 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetAssignedRolesRequest(String groupId, Boolean includePermissions) { + + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/groups/" + UrlEncoder.encodeValue(request.groupId) + "/roles/oidc", + request -> request.includePermissions != null ? Map.of("includePermissions", request.includePermissions) + : Collections.emptyMap(), + (statusCode, + response) -> (List) JSON.deserialize(response, TypeToken.getParameterized(List.class, Role.class))); + + public static GetAssignedRolesRequest of(String groupId) { + return of(groupId, ObjectBuilder.identity()); + } + + public static GetAssignedRolesRequest of(String groupId, + Function> fn) { + return fn.apply(new Builder(groupId)).build(); + } + + public GetAssignedRolesRequest(Builder builder) { + this(builder.groupId, builder.includePermissions); + } + + public static class Builder implements ObjectBuilder { + private final String groupId; + private Boolean includePermissions; + + public Builder(String groupId) { + this.groupId = groupId; + } + + public Builder includePermissions(boolean includePermissions) { + this.includePermissions = includePermissions; + return this; + } + + @Override + public GetAssignedRolesRequest build() { + return new GetAssignedRolesRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetKnownGroupNamesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetKnownGroupNamesRequest.java new file mode 100644 index 000000000..deb1dc343 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GetKnownGroupNamesRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record GetKnownGroupNamesRequest() { + + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/groups/oidc", + request -> Collections.emptyMap(), + (statusCode, + response) -> (List) JSON.deserialize(response, TypeToken.getParameterized(List.class, String.class))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GroupType.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GroupType.java new file mode 100644 index 000000000..4adc41cb1 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/GroupType.java @@ -0,0 +1,8 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import com.google.gson.annotations.SerializedName; + +public enum GroupType { + @SerializedName("oidc") + OIDC; +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/RevokeRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/RevokeRolesRequest.java new file mode 100644 index 000000000..6b6486ff6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/RevokeRolesRequest.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record RevokeRolesRequest(String groupId, List roleNames) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/groups/" + UrlEncoder.encodeValue(request.groupId) + "/revoke", + request -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.roleNames, GroupType.OIDC))); + + /** Request body should be {"roles": [...], "groupType": "oidc"} */ + private static record Body( + @SerializedName("roles") List roleNames, + @SerializedName("groupType") GroupType groupType) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/UserType.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/UserType.java new file mode 100644 index 000000000..7a490415d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/UserType.java @@ -0,0 +1,12 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import com.google.gson.annotations.SerializedName; + +public enum UserType { + @SerializedName("db_user") + DB_USER, + @SerializedName("db_end_user") + DB_ENV_USER, + @SerializedName("oidc") + OIDC +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClient.java new file mode 100644 index 000000000..0ea438afd --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClient.java @@ -0,0 +1,95 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateGroupsClient { + private final RestTransport restTransport; + + public WeaviateGroupsClient(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Get the roles assigned an OIDC group. + * + * @param groupId OIDC group ID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List assignedRoles(String groupId) throws IOException { + return this.restTransport.performRequest(GetAssignedRolesRequest.of(groupId), GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Get the roles assigned an OIDC group. + * + * @param groupId OIDC group ID. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List assignedRoles(String groupId, + Function> fn) throws IOException { + return this.restTransport.performRequest(GetAssignedRolesRequest.of(groupId, fn), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Get the names of known OIDC groups. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List knownGroupNames() throws IOException { + return this.restTransport.performRequest(null, GetKnownGroupNamesRequest._ENDPOINT); + } + + /** + * Assign roles to OIDC group. + * + * @param groupId OIDC group ID. + * @param roleNames Role names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void assignRoles(String groupId, String... roleNames) throws IOException { + this.restTransport.performRequest(new AssignRolesRequest(groupId, Arrays.asList(roleNames)), + AssignRolesRequest._ENDPOINT); + } + + /** + * Revoke roles from OIDC group. + * + * @param groupId OIDC group ID. + * @param roleNames Role names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void revokeRoles(String groupId, String... roleNames) throws IOException { + this.restTransport.performRequest(new RevokeRolesRequest(groupId, Arrays.asList(roleNames)), + RevokeRolesRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClientAsync.java new file mode 100644 index 000000000..9932a910d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/groups/WeaviateGroupsClientAsync.java @@ -0,0 +1,67 @@ +package io.weaviate.client6.v1.api.rbac.groups; + +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateGroupsClientAsync { + private final RestTransport restTransport; + + public WeaviateGroupsClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Get the roles assigned an OIDC group. + * + * @param groupId OIDC group ID. + */ + public CompletableFuture> assignedRoles(String groupId) { + return this.restTransport.performRequestAsync(GetAssignedRolesRequest.of(groupId), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Get the roles assigned an OIDC group. + * + * @param groupId OIDC group ID. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> assignedRoles(String groupId, + Function> fn) { + return this.restTransport.performRequestAsync(GetAssignedRolesRequest.of(groupId, fn), + GetAssignedRolesRequest._ENDPOINT); + } + + /** Get the names of known OIDC groups. */ + public CompletableFuture> knownGroupNames() { + return this.restTransport.performRequestAsync(null, GetKnownGroupNamesRequest._ENDPOINT); + } + + /** + * Assign roles to OIDC group. + * + * @param groupId OIDC group ID. + * @param roleNames Role names. + */ + public CompletableFuture assignRoles(String groupId, String... roleNames) { + return this.restTransport.performRequestAsync(new AssignRolesRequest(groupId, Arrays.asList(roleNames)), + AssignRolesRequest._ENDPOINT); + } + + /** + * Revoke roles from OIDC group. + * + * @param groupId OIDC group ID. + * @param roleNames Role names. + */ + public CompletableFuture revokeRoles(String groupId, String... roleNames) { + return this.restTransport.performRequestAsync(new RevokeRolesRequest(groupId, Arrays.asList(roleNames)), + RevokeRolesRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/AddPermissionsRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/AddPermissionsRequest.java new file mode 100644 index 000000000..8034181da --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/AddPermissionsRequest.java @@ -0,0 +1,24 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record AddPermissionsRequest(String roleName, List permissions) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/add-permissions", + __ -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.permissions))); + + /** Request body must be {"permissions": [...]}. */ + private static record Body(@SerializedName("permissions") List permissions) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/CreateRoleRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/CreateRoleRequest.java new file mode 100644 index 000000000..93502fad7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/CreateRoleRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record CreateRoleRequest(Role role) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + __ -> "/authz/roles", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.role)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/DeleteRoleRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/DeleteRoleRequest.java new file mode 100644 index 000000000..a966c582c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/DeleteRoleRequest.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record DeleteRoleRequest(String roleName) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "DELETE", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName), + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetAssignedUsersRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetAssignedUsersRequest.java new file mode 100644 index 000000000..80e889a16 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetAssignedUsersRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetAssignedUsersRequest(String roleName) { + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/users", + __ -> Collections.emptyMap(), + (statusCode, response) -> (List) JSON.deserialize(response, + TypeToken.getParameterized(List.class, String.class))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetGroupAssignementsRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetGroupAssignementsRequest.java new file mode 100644 index 000000000..71f1ffee3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetGroupAssignementsRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetGroupAssignementsRequest(String roleName) { + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/group-assignments", + __ -> Collections.emptyMap(), + (statusCode, response) -> (List) JSON.deserialize(response, + TypeToken.getParameterized(List.class, GroupAssignment.class))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetRoleRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetRoleRequest.java new file mode 100644 index 000000000..a27da0866 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetRoleRequest.java @@ -0,0 +1,18 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.Optional; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetRoleRequest(String roleName) { + public static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + __ -> "GET", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName), + __ -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, Role.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetUserAssignementsRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetUserAssignementsRequest.java new file mode 100644 index 000000000..501f736e6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GetUserAssignementsRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetUserAssignementsRequest(String roleName) { + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/user-assignments", + __ -> Collections.emptyMap(), + (statusCode, response) -> (List) JSON.deserialize(response, + TypeToken.getParameterized(List.class, UserAssignment.class))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GroupAssignment.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GroupAssignment.java new file mode 100644 index 000000000..424aa6ea7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/GroupAssignment.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.groups.GroupType; + +public record GroupAssignment( + @SerializedName("groupId") String groupId, + @SerializedName("groupType") GroupType groupType) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/HasPermissionRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/HasPermissionRequest.java new file mode 100644 index 000000000..32ed0ae28 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/HasPermissionRequest.java @@ -0,0 +1,18 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; + +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record HasPermissionRequest(String roleName, Permission permission) { + public static final Endpoint _ENDPOINT = new SimpleEndpoint<>( + __ -> "POST", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/has-permission", + __ -> Collections.emptyMap(), + request -> JSON.serialize(request.permission), + (statusCode, response) -> JSON.deserialize(response, Boolean.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/ListRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/ListRolesRequest.java new file mode 100644 index 000000000..1ea57e1b3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/ListRolesRequest.java @@ -0,0 +1,21 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListRolesRequest() { + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + __ -> "/authz/roles", + __ -> Collections.emptyMap(), + (statusCode, response) -> (List) JSON.deserialize(response, + TypeToken.getParameterized(List.class, Role.class))); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RemovePermissionsRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RemovePermissionsRequest.java new file mode 100644 index 000000000..b40749fdc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RemovePermissionsRequest.java @@ -0,0 +1,24 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record RemovePermissionsRequest(String roleName, List permissions) { + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName) + "/remove-permissions", + __ -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.permissions))); + + /** Request body must be {"permissions": [...]}. */ + private static record Body(@SerializedName("permissions") List permissions) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RoleExistsRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RoleExistsRequest.java new file mode 100644 index 000000000..155dd6819 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/RoleExistsRequest.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record RoleExistsRequest(String roleName) { + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + __ -> "GET", + request -> "/authz/roles/" + UrlEncoder.encodeValue(request.roleName), + __ -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/UserAssignment.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/UserAssignment.java new file mode 100644 index 000000000..ba759707e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/UserAssignment.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.users.UserType; + +public record UserAssignment( + @SerializedName("userId") String userId, + @SerializedName("userType") UserType userType) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClient.java new file mode 100644 index 000000000..4cea55f8b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClient.java @@ -0,0 +1,202 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateRolesClient { + private final RestTransport restTransport; + + public WeaviateRolesClient(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Create a new role. + * + * @param roleName Role name. + * @param permissions Permissions granted to the role. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(String roleName, Permission... permissions) throws IOException { + create(roleName, Arrays.asList(permissions)); + } + + /** + * Create a new role. + * + * @param roleName Role name. + * @param permissions Permissions granted to the role. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void create(String roleName, List permissions) throws IOException { + var role = new Role(roleName, permissions); + this.restTransport.performRequest(new CreateRoleRequest(role), CreateRoleRequest._ENDPOINT); + } + + /** + * Check if a role with a given name exists. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean exists(String roleName) throws IOException { + return this.restTransport.performRequest(new RoleExistsRequest(roleName), RoleExistsRequest._ENDPOINT); + } + + /** + * Fetch role definition. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional get(String roleName) throws IOException { + return this.restTransport.performRequest(new GetRoleRequest(roleName), GetRoleRequest._ENDPOINT); + } + + /** + * List all existing roles. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list() throws IOException { + return this.restTransport.performRequest(null, ListRolesRequest._ENDPOINT); + } + + /** + * Delete a role. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void delete(String roleName) throws IOException { + this.restTransport.performRequest(new DeleteRoleRequest(roleName), DeleteRoleRequest._ENDPOINT); + } + + /** + * Add permissions to a role. + * + * @param roleName Role name. + * @param permissions Permissions to add to the role. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void addPermissions(String roleName, Permission... permissions) throws IOException { + this.restTransport.performRequest(new AddPermissionsRequest(roleName, Arrays.asList(permissions)), + AddPermissionsRequest._ENDPOINT); + } + + /** + * Remove permissions from a role. + * + * @param roleName Role name. + * @param permissions Permissions to remove from the role. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void removePermissions(String roleName, Permission... permissions) throws IOException { + this.restTransport.performRequest(new RemovePermissionsRequest(roleName, Arrays.asList(permissions)), + RemovePermissionsRequest._ENDPOINT); + } + + /** + * Check if a role has a set of permissions. + * + * @param roleName Role name. + * @param permission Permission to check. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean hasPermission(String roleName, Permission permission) throws IOException { + return this.restTransport.performRequest(new HasPermissionRequest(roleName, permission), + HasPermissionRequest._ENDPOINT); + } + + /** + * Get IDs of all users this role is assigned to. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List assignedUserIds(String roleName) throws IOException { + return this.restTransport.performRequest(new GetAssignedUsersRequest(roleName), GetAssignedUsersRequest._ENDPOINT); + } + + /** + * Get IDs of all users this role is assigned to along with their user type. + * + *

+ * Note that, unlike {@link #assignedUserIds}, this method MAY return multiple + * entries for the same user ID if OIDCS authentication is enabled: once with + * "db_*" and another time with "oidc" user type. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List userAssignments(String roleName) throws IOException { + return this.restTransport.performRequest(new GetUserAssignementsRequest(roleName), + GetUserAssignementsRequest._ENDPOINT); + } + + /** + * Get IDs of all groups this role is assigned to along with their group type. + * + * @param roleName Role name. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List groupAssignments(String roleName) throws IOException { + return this.restTransport.performRequest(new GetGroupAssignementsRequest(roleName), + GetGroupAssignementsRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClientAsync.java new file mode 100644 index 000000000..64e60fc8c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/roles/WeaviateRolesClientAsync.java @@ -0,0 +1,129 @@ +package io.weaviate.client6.v1.api.rbac.roles; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.api.rbac.Permission; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateRolesClientAsync { + private final RestTransport restTransport; + + public WeaviateRolesClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + } + + /** + * Create a new role. + * + * @param roleName Role name. + * @param permissions Permissions granted to the role. + */ + public CompletableFuture create(String roleName, Permission... permissions) { + var role = new Role(roleName, permissions); + return this.restTransport.performRequestAsync(new CreateRoleRequest(role), CreateRoleRequest._ENDPOINT); + } + + /** + * Check if a role with a given name exists. + * + * @param roleName Role name. + */ + public CompletableFuture exists(String roleName) { + return this.restTransport.performRequestAsync(new RoleExistsRequest(roleName), RoleExistsRequest._ENDPOINT); + } + + /** + * Fetch role definition. + * + * @param roleName Role name. + */ + public CompletableFuture> get(String roleName) { + return this.restTransport.performRequestAsync(new GetRoleRequest(roleName), GetRoleRequest._ENDPOINT); + } + + /** List all existing roles. */ + public CompletableFuture> list() { + return this.restTransport.performRequestAsync(null, ListRolesRequest._ENDPOINT); + } + + /** + * Delete a role. + * + * @param roleName Role name. + */ + public CompletableFuture delete(String roleName) { + return this.restTransport.performRequestAsync(new DeleteRoleRequest(roleName), DeleteRoleRequest._ENDPOINT); + } + + /** + * Add permissions to a role. + * + * @param roleName Role name. + * @param permissions Permissions to add to the role. + */ + public CompletableFuture addPermissions(String roleName, Permission... permissions) { + return this.restTransport.performRequestAsync(new AddPermissionsRequest(roleName, Arrays.asList(permissions)), + AddPermissionsRequest._ENDPOINT); + } + + /** + * Remove permissions from a role. + * + * @param roleName Role name. + * @param permissions Permissions to remove from the role. + */ + public CompletableFuture removePermissions(String roleName, Permission... permissions) { + return this.restTransport.performRequestAsync(new RemovePermissionsRequest(roleName, Arrays.asList(permissions)), + RemovePermissionsRequest._ENDPOINT); + } + + /** + * Check if a role has a set of permissions. + * + * @param roleName Role name. + * @param permission Permission to check. + */ + public CompletableFuture hasPermission(String roleName, Permission permission) { + return this.restTransport.performRequestAsync(new HasPermissionRequest(roleName, permission), + HasPermissionRequest._ENDPOINT); + } + + /** + * Get IDs of all users this role is assigned to. + * + * @param roleName Role name. + */ + public CompletableFuture> assignedUserIds(String roleName) { + return this.restTransport.performRequestAsync(new GetAssignedUsersRequest(roleName), + GetAssignedUsersRequest._ENDPOINT); + } + + /** + * Get IDs of all users this role is assigned to along with their user type. + * + *

+ * Note that, unlike {@link #assignedUserIds}, this method MAY return multiple + * entries for the same user ID if OIDCS authentication is enabled: once with + * "db_*" and another time with "oidc" user type. + * + * @param roleName Role name. + */ + public CompletableFuture> userAssignments(String roleName) { + return this.restTransport.performRequestAsync(new GetUserAssignementsRequest(roleName), + GetUserAssignementsRequest._ENDPOINT); + } + + /** + * Get IDs of all groups this role is assigned to along with their group type. + * + * @param roleName Role name. + */ + public CompletableFuture> groupAssignments(String roleName) { + return this.restTransport.performRequestAsync(new GetGroupAssignementsRequest(roleName), + GetGroupAssignementsRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/ActivateDbUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/ActivateDbUserRequest.java new file mode 100644 index 000000000..035f038a2 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/ActivateDbUserRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record ActivateDbUserRequest(String userId) { + + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + __ -> "POST", + request -> "/users/db/" + UrlEncoder.encodeValue(((ActivateDbUserRequest) request).userId) + "/activate", + request -> Collections.emptyMap()) + .allowStatus(409); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/AssignRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/AssignRolesRequest.java new file mode 100644 index 000000000..95c3481f4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/AssignRolesRequest.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record AssignRolesRequest(String userId, UserType userType, List roleNames) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/users/" + UrlEncoder.encodeValue(request.userId) + "/assign", + request -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.roleNames, request.userType))); + + /** Request body should be {"roles": [...], "userType": ""} */ + private static record Body( + @SerializedName("roles") List roleNames, + @SerializedName("userType") UserType userType) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserRequest.java new file mode 100644 index 000000000..7b425cff5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserRequest.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record CreateDbUserRequest(String userId) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.noBody( + __ -> "POST", + request -> "/users/db/" + UrlEncoder.encodeValue(request.userId), + request -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, CreateDbUserResponse.class).apiKey()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserResponse.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserResponse.java new file mode 100644 index 000000000..73ff10716 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/CreateDbUserResponse.java @@ -0,0 +1,6 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import com.google.gson.annotations.SerializedName; + +public record CreateDbUserResponse(@SerializedName("apikey") String apiKey) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUser.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUser.java new file mode 100644 index 000000000..f73313b5c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUser.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.time.OffsetDateTime; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +public record DbUser( + @SerializedName("userId") String id, + @SerializedName("dbUserType") UserType userType, + @SerializedName("active") boolean active, + @SerializedName("roles") List roleNames, + @SerializedName("createdAt") OffsetDateTime createdAt, + @SerializedName("lastUsedAt") OffsetDateTime lastUsedAt, + @SerializedName("apiKeyFirstLetters") String apiKeyFirstLetters) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClient.java new file mode 100644 index 000000000..18d77d310 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClient.java @@ -0,0 +1,150 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class DbUsersClient extends NamespacedUsersClient { + + public DbUsersClient(RestTransport restTransport) { + super(restTransport, UserType.DB_USER); + } + + /** + * Create a new "db" user. + * + * @param userId User ID. + * @return API key for the created user. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public String create(String userId) throws IOException { + return this.restTransport.performRequest(new CreateDbUserRequest(userId), CreateDbUserRequest._ENDPOINT); + } + + /** + * Delete a "db" user. + * + * @param userId User ID. + * @return {@code true} if the user was deleted, {@code false} if there was no user to delete. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean delete(String userId) throws IOException { + return this.restTransport.performRequest(new DeleteDbUserRequest(userId), DeleteDbUserRequest._ENDPOINT); + } + + /** + * Activate a "db" user. + * + * @param userId User ID. + * @return {@code true} if the user was activated, {@code false} if the user was already active. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean activate(String userId) throws IOException { + return this.restTransport.performRequest(new ActivateDbUserRequest(userId), ActivateDbUserRequest._ENDPOINT); + } + + /** + * Deactivate a "db" user. + * + * @param userId User ID. + * @return {@code true} if the user was deactivated, {@code false} if the user was already deactivated. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public boolean deactivate(String userId) throws IOException { + return this.restTransport.performRequest(new DeactivateDbUserRequest(userId), DeactivateDbUserRequest._ENDPOINT); + } + + /** + * Rotate API key of the "db" user. + * + * @param userId User ID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public String rotateKey(String userId) throws IOException { + return this.restTransport.performRequest(new RotateDbUserKeyRequest(userId), RotateDbUserKeyRequest._ENDPOINT); + } + + /** + * Fetch "db" user info. + * + * @param userId User ID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional byName(String userId) throws IOException { + return this.restTransport.performRequest(GetDbUserRequest.of(userId), GetDbUserRequest._ENDPOINT); + } + + /** + * Fetch "db" user info. + * + * @param userId User ID. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public Optional byName(String userId, Function> fn) + throws IOException { + return this.restTransport.performRequest(GetDbUserRequest.of(userId, fn), GetDbUserRequest._ENDPOINT); + } + + /** + * List all "db" users. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list() + throws IOException { + return this.restTransport.performRequest(ListDbUsersRequest.of(), ListDbUsersRequest._ENDPOINT); + } + + /** + * List all "db" users. + * + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List list(Function> fn) + throws IOException { + return this.restTransport.performRequest(ListDbUsersRequest.of(fn), ListDbUsersRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClientAsync.java new file mode 100644 index 000000000..0d291ca43 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DbUsersClientAsync.java @@ -0,0 +1,102 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class DbUsersClientAsync extends NamespacedUsersClientAsync { + + public DbUsersClientAsync(RestTransport restTransport) { + super(restTransport, UserType.DB_USER); + } + + /** + * Create a new "db" user. + * + * @param userId User ID. + * @return API key for the created user. + */ + public CompletableFuture create(String userId) throws IOException { + return this.restTransport.performRequestAsync(new CreateDbUserRequest(userId), CreateDbUserRequest._ENDPOINT); + } + + /** + * Delete a "db" user. + * + * @param userId User ID. + */ + public CompletableFuture delete(String userId) throws IOException { + return this.restTransport.performRequestAsync(new DeleteDbUserRequest(userId), DeleteDbUserRequest._ENDPOINT); + } + + /** + * Activate a "db" user. + * + * @param userId User ID. + */ + public CompletableFuture activate(String userId) throws IOException { + return this.restTransport.performRequestAsync(new ActivateDbUserRequest(userId), ActivateDbUserRequest._ENDPOINT); + } + + /** + * Deactivate a "db" user. + * + * @param userId User ID. + */ + public CompletableFuture deactivate(String userId) throws IOException { + return this.restTransport.performRequestAsync(new DeactivateDbUserRequest(userId), + DeactivateDbUserRequest._ENDPOINT); + } + + /** + * Rotate API key of the "db" user. + * + * @param userId User ID. + */ + public CompletableFuture rotateKey(String userId) throws IOException { + return this.restTransport.performRequestAsync(new RotateDbUserKeyRequest(userId), RotateDbUserKeyRequest._ENDPOINT); + } + + /** + * Fetch "db" user info. + * + * @param userId User ID. + */ + public CompletableFuture> byName(String userId) throws IOException { + return this.restTransport.performRequestAsync(GetDbUserRequest.of(userId), GetDbUserRequest._ENDPOINT); + } + + /** + * Fetch "db" user info. + * + * @param userId User ID. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> byName(String userId, + Function> fn) + throws IOException { + return this.restTransport.performRequestAsync(GetDbUserRequest.of(userId, fn), GetDbUserRequest._ENDPOINT); + } + + /** List all "db" users. */ + public CompletableFuture> list() + throws IOException { + return this.restTransport.performRequestAsync(ListDbUsersRequest.of(), ListDbUsersRequest._ENDPOINT); + } + + /** + * List all "db" users. + * + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> list( + Function> fn) + throws IOException { + return this.restTransport.performRequestAsync(ListDbUsersRequest.of(fn), ListDbUsersRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeactivateDbUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeactivateDbUserRequest.java new file mode 100644 index 000000000..959f0a5b3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeactivateDbUserRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record DeactivateDbUserRequest(String userId) { + + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + __ -> "POST", + request -> "/users/db/" + UrlEncoder.encodeValue(((DeactivateDbUserRequest) request).userId) + "/deactivate", + request -> Collections.emptyMap()) + .allowStatus(409); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeleteDbUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeleteDbUserRequest.java new file mode 100644 index 000000000..ad9caf592 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/DeleteDbUserRequest.java @@ -0,0 +1,15 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record DeleteDbUserRequest(String userId) { + + public static final Endpoint _ENDPOINT = BooleanEndpoint.noBody( + __ -> "DELETE", + request -> "/users/db/" + UrlEncoder.encodeValue(request.userId), + request -> Collections.emptyMap()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetAssignedRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetAssignedRolesRequest.java new file mode 100644 index 000000000..05644046c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetAssignedRolesRequest.java @@ -0,0 +1,61 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetAssignedRolesRequest(String userId, UserType userType, Boolean includePermissions) { + + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/authz/users/" + UrlEncoder.encodeValue(request.userId) + "/roles/" + request.userType.jsonValue(), + request -> request.includePermissions != null ? Map.of("includePermissions", request.includePermissions) + : Collections.emptyMap(), + (statusCode, + response) -> (List) JSON.deserialize(response, TypeToken.getParameterized(List.class, Role.class))); + + public static GetAssignedRolesRequest of(String userId, UserType userType) { + return of(userId, userType, ObjectBuilder.identity()); + } + + public static GetAssignedRolesRequest of(String userId, UserType userType, + Function> fn) { + return fn.apply(new Builder(userId, userType)).build(); + } + + public GetAssignedRolesRequest(Builder builder) { + this(builder.userId, builder.userType, builder.includePermissions); + } + + public static class Builder implements ObjectBuilder { + private final String userId; + private final UserType userType; + private Boolean includePermissions; + + public Builder(String userId, UserType userType) { + this.userId = userId; + this.userType = userType; + } + + public Builder includePermissions(boolean includePermissions) { + this.includePermissions = includePermissions; + return this; + } + + @Override + public GetAssignedRolesRequest build() { + return new GetAssignedRolesRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetDbUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetDbUserRequest.java new file mode 100644 index 000000000..032ac8d1e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetDbUserRequest.java @@ -0,0 +1,54 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; +import java.util.Map; +import java.util.Optional; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.OptionalEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record GetDbUserRequest(String userId, Boolean includeLastUsedAt) { + + public static final Endpoint> _ENDPOINT = OptionalEndpoint.noBodyOptional( + __ -> "GET", + request -> "/users/db/" + UrlEncoder.encodeValue(request.userId), + request -> request.includeLastUsedAt != null + ? Map.of("includeLastUsedTime", request.includeLastUsedAt) + : Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, DbUser.class)); + + public static GetDbUserRequest of(String userId) { + return of(userId, ObjectBuilder.identity()); + } + + public static GetDbUserRequest of(String userId, Function> fn) { + return fn.apply(new Builder(userId)).build(); + } + + public GetDbUserRequest(Builder builder) { + this(builder.userId, builder.includeLastUsedAt); + } + + public static class Builder implements ObjectBuilder { + private final String userId; + private Boolean includeLastUsedAt; + + public Builder(String userId) { + this.userId = userId; + } + + public Builder includeLastUsedAt(boolean includeLastUsedAt) { + this.includeLastUsedAt = includeLastUsedAt; + return this; + } + + @Override + public GetDbUserRequest build() { + return new GetDbUserRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetMyUserRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetMyUserRequest.java new file mode 100644 index 000000000..e467e17fc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/GetMyUserRequest.java @@ -0,0 +1,16 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record GetMyUserRequest() { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + __ -> "/users/own-info", + __ -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, User.class)); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/ListDbUsersRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/ListDbUsersRequest.java new file mode 100644 index 000000000..72fe28172 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/ListDbUsersRequest.java @@ -0,0 +1,53 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public record ListDbUsersRequest(Boolean includeLastUsedAt) { + + @SuppressWarnings("unchecked") + public static final Endpoint> _ENDPOINT = SimpleEndpoint.noBody( + __ -> "GET", + request -> "/users/db", + request -> request.includeLastUsedAt != null + ? Map.of("includeLastUsedTime", request.includeLastUsedAt) + : Collections.emptyMap(), + (statusCode, + response) -> (List) JSON.deserialize(response, + TypeToken.getParameterized(List.class, DbUser.class))); + + public static ListDbUsersRequest of() { + return of(ObjectBuilder.identity()); + } + + public static ListDbUsersRequest of(Function> fn) { + return fn.apply(new Builder()).build(); + } + + public ListDbUsersRequest(Builder builder) { + this(builder.includeLastUsedAt); + } + + public static class Builder implements ObjectBuilder { + private Boolean includeLastUsedAt; + + public Builder includeLastUsedAt(boolean includeLastUsedAt) { + this.includeLastUsedAt = includeLastUsedAt; + return this; + } + + @Override + public ListDbUsersRequest build() { + return new ListDbUsersRequest(this); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClient.java new file mode 100644 index 000000000..ff3d311b4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClient.java @@ -0,0 +1,85 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public abstract class NamespacedUsersClient { + protected final RestTransport restTransport; + private final UserType userType; + + public NamespacedUsersClient(RestTransport restTransport, UserType userType) { + this.restTransport = restTransport; + this.userType = userType; + } + + /** + * Get the roles assigned a user with type {@link #userType}. + * + * @param userId OIDC group ID. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List assignedRoles(String userId) throws IOException { + return this.restTransport.performRequest(GetAssignedRolesRequest.of(userId, userType), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Get the roles assigned a user with type {@link #userType}. + * + * @param userId OIDC group ID. + * @param fn Lambda expression for optional parameters. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public List assignedRoles(String userId, + Function> fn) throws IOException { + return this.restTransport.performRequest(GetAssignedRolesRequest.of(userId, userType, fn), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Assing roles to a user with type {@link #userType}. + * + * @param userId User ID. + * @param roleNames Role names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void assignRoles(String userId, String... roleNames) throws IOException { + this.restTransport.performRequest(new AssignRolesRequest(userId, userType, Arrays.asList(roleNames)), + AssignRolesRequest._ENDPOINT); + } + + /** + * Revoke roles from a user with type {@link #userType}. + * + * @param userId User ID. + * @param roleNames Role names. + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public void revokeRoles(String userId, String... roleNames) throws IOException { + this.restTransport.performRequest(new RevokeRolesRequest(userId, userType, Arrays.asList(roleNames)), + RevokeRolesRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClientAsync.java new file mode 100644 index 000000000..7053b5abf --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/NamespacedUsersClientAsync.java @@ -0,0 +1,64 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public abstract class NamespacedUsersClientAsync { + protected final RestTransport restTransport; + private final UserType userType; + + public NamespacedUsersClientAsync(RestTransport restTransport, UserType userType) { + this.restTransport = restTransport; + this.userType = userType; + } + + /** + * Get the roles assigned a user with type {@link #userType}. + * + * @param userId OIDC group ID. + */ + public CompletableFuture> assignedRoles(String userId) { + return this.restTransport.performRequestAsync(GetAssignedRolesRequest.of(userId, userType), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Get the roles assigned a user with type {@link #userType}. + * + * @param userId OIDC group ID. + * @param fn Lambda expression for optional parameters. + */ + public CompletableFuture> assignedRoles(String userId, + Function> fn) { + return this.restTransport.performRequestAsync(GetAssignedRolesRequest.of(userId, userType, fn), + GetAssignedRolesRequest._ENDPOINT); + } + + /** + * Assing roles to a user with type {@link #userType}. + * + * @param userId User ID. + * @param roleNames Role names. + */ + public CompletableFuture assignRoles(String userId, String... roleNames) { + return this.restTransport.performRequestAsync(new AssignRolesRequest(userId, userType, Arrays.asList(roleNames)), + AssignRolesRequest._ENDPOINT); + } + + /** + * Revoke roles from a user with type {@link #userType}. + * + * @param userId User ID. + * @param roleNames Role names. + */ + public CompletableFuture revokeRoles(String userId, String... roleNames) { + return this.restTransport.performRequestAsync(new RevokeRolesRequest(userId, userType, Arrays.asList(roleNames)), + RevokeRolesRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClient.java new file mode 100644 index 000000000..1159c8c0a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClient.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class OidcUsersClient extends NamespacedUsersClient { + + public OidcUsersClient(RestTransport restTransport) { + super(restTransport, UserType.OIDC); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClientAsync.java new file mode 100644 index 000000000..7d587005e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/OidcUsersClientAsync.java @@ -0,0 +1,10 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class OidcUsersClientAsync extends NamespacedUsersClientAsync { + + public OidcUsersClientAsync(RestTransport restTransport) { + super(restTransport, UserType.OIDC); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/RevokeRolesRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RevokeRolesRequest.java new file mode 100644 index 000000000..d9e6f2c3e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RevokeRolesRequest.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record RevokeRolesRequest(String userId, UserType userType, List roleNames) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.sideEffect( + __ -> "POST", + request -> "/authz/users/" + UrlEncoder.encodeValue(request.userId) + "/revoke", + request -> Collections.emptyMap(), + request -> JSON.serialize(new Body(request.roleNames, request.userType))); + + /** Request body should be {"roles": [...], "userType": ""} */ + private static record Body( + @SerializedName("roles") List roleNames, + @SerializedName("userType") UserType userType) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyRequest.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyRequest.java new file mode 100644 index 000000000..9d394f545 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyRequest.java @@ -0,0 +1,17 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.Collections; + +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; +import io.weaviate.client6.v1.internal.rest.UrlEncoder; + +public record RotateDbUserKeyRequest(String userId) { + + public static final Endpoint _ENDPOINT = SimpleEndpoint.noBody( + __ -> "POST", + request -> "/users/db/" + UrlEncoder.encodeValue(request.userId) + "/rotate-key", + request -> Collections.emptyMap(), + (statusCode, response) -> JSON.deserialize(response, RotateDbUserKeyResponse.class).apiKey()); +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyResponse.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyResponse.java new file mode 100644 index 000000000..6099dd768 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/RotateDbUserKeyResponse.java @@ -0,0 +1,6 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import com.google.gson.annotations.SerializedName; + +public record RotateDbUserKeyResponse(@SerializedName("apikey") String apiKey) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/User.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/User.java new file mode 100644 index 000000000..d31f66dc7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/User.java @@ -0,0 +1,12 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.rbac.Role; + +public record User( + @SerializedName("username") String id, + @SerializedName("roles") List roles) { +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/UserType.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/UserType.java new file mode 100644 index 000000000..5aefa28bb --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/UserType.java @@ -0,0 +1,22 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import com.google.gson.annotations.SerializedName; + +public enum UserType { + @SerializedName(value = "db", alternate = "db_user") + DB_USER("db"), + @SerializedName(value = "db", alternate = "db_env_user") + DB_ENV_USER("db"), + @SerializedName("oidc") + OIDC("oidc"); + + private final String jsonValue; + + private UserType(String jsonValue) { + this.jsonValue = jsonValue; + } + + public String jsonValue() { + return jsonValue; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClient.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClient.java new file mode 100644 index 000000000..300843d49 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClient.java @@ -0,0 +1,38 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.io.IOException; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateUsersClient { + private final RestTransport restTransport; + + /** + * Client for managing {@link UserType#DB_USER} and {@link UserType#DB_ENV_USER} + * users. + */ + public final DbUsersClient db; + + /** Client for managing {@link UserType#OIDC} users. */ + public final OidcUsersClient oidc; + + public WeaviateUsersClient(RestTransport restTransport) { + this.restTransport = restTransport; + this.db = new DbUsersClient(restTransport); + this.oidc = new OidcUsersClient(restTransport); + } + + /** + * Get my user info. + * + * @throws WeaviateApiException in case the server returned with an + * error status code. + * @throws IOException in case the request was not sent successfully + * due to a malformed request, a networking error + * or the server being unavailable. + */ + public User myUser() throws IOException { + return this.restTransport.performRequest(null, GetMyUserRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClientAsync.java new file mode 100644 index 000000000..8104a8672 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/api/rbac/users/WeaviateUsersClientAsync.java @@ -0,0 +1,29 @@ +package io.weaviate.client6.v1.api.rbac.users; + +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class WeaviateUsersClientAsync { + private final RestTransport restTransport; + + /** + * Client for managing {@link UserType#DB_USER} and {@link UserType#DB_ENV_USER} + * users. + */ + public final DbUsersClientAsync db; + + /** Client for managing {@link UserType#OIDC} users. */ + public final OidcUsersClientAsync oidc; + + public WeaviateUsersClientAsync(RestTransport restTransport) { + this.restTransport = restTransport; + this.db = new DbUsersClientAsync(restTransport); + this.oidc = new OidcUsersClientAsync(restTransport); + } + + /** Get my user info. */ + public CompletableFuture myUser() { + return this.restTransport.performRequestAsync(null, GetMyUserRequest._ENDPOINT); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/AsyncTokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/AsyncTokenProvider.java new file mode 100644 index 000000000..ec083d274 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/AsyncTokenProvider.java @@ -0,0 +1,83 @@ +package io.weaviate.client6.v1.internal; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import io.weaviate.client6.v1.internal.TokenProvider.Token; + +/** + * AsyncTokenProvider obtains authentication tokens asynchronously + * and can be used in a non-blocking context. + * + * As implementors are likely to schedule token fetches on a thread pool, + * instances must be closed to avoid resource leaks. + */ +public interface AsyncTokenProvider extends AutoCloseable { + CompletableFuture getToken(); + + CompletableFuture getToken(Executor executor); + + /** + * Create an {@link AsyncTokenProvider} instance from an existing + * {@link TokenProvider}. The inner provider MAY be called from + * multiple instances and MUST be thread-safe. + * + * Either use in a try-with-resources block or close after usage explicitly. + */ + static AsyncTokenProvider wrap(TokenProvider tp) { + return new Default(tp); + } + + /** + * AsyncTokenProvider fetches tokens in a + * shared single background thread. + */ + public static class Default implements AsyncTokenProvider { + /** + * Shared executor service. This way all instances + * can share the same thread pool. + */ + private static ExecutorService exec; + /** Shut down {@link #exec} once refCount reaches 0. */ + private static int refCount = 0; + + private final TokenProvider provider; + + Default(TokenProvider tp) { + synchronized (Default.class) { + if (refCount == 0) { + exec = Executors.newSingleThreadExecutor(); + } + refCount++; + } + this.provider = tp; + } + + /** Get token with the default single-thread executor. */ + @Override + public CompletableFuture getToken() { + return getToken(exec); + } + + /** Get token with a custom executor. */ + @Override + public CompletableFuture getToken(Executor executor) { + return CompletableFuture.supplyAsync(provider::getToken, executor); + } + + @Override + public void close() throws Exception { + provider.close(); + + synchronized (Default.class) { + refCount--; + if (refCount == 0 && exec != null) { + exec.shutdown(); + exec = null; + } + } + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/BackgroundTokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/BackgroundTokenProvider.java new file mode 100644 index 000000000..2d95c480d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/BackgroundTokenProvider.java @@ -0,0 +1,61 @@ +package io.weaviate.client6.v1.internal; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class BackgroundTokenProvider implements TokenProvider { + private final ScheduledExecutorService exec; + private final TokenProvider provider; + + /** + * Create a background task to periodically refresh the token. + * + *

+ * This method will wrap the TokenProvider in {@link ReuseTokenProvider} + * before passing it on to the constructor to cache the token + * in-between the refreshes. + * + * If TokenProvider is an instance of BackgroundTokenProvider + * it is returned immediately. + */ + public static TokenProvider wrap(TokenProvider tp) { + if (tp instanceof BackgroundTokenProvider) { + return tp; + } + return new BackgroundTokenProvider(ReuseTokenProvider.wrap(null, tp)); + } + + private BackgroundTokenProvider(TokenProvider tp) { + this.provider = tp; + this.exec = Executors.newSingleThreadScheduledExecutor(); + + scheduleNextRefresh(); + } + + @Override + public Token getToken() { + return provider.getToken(); + } + + /** + * Fetch the token and schedule a task to refresh it + * after {@link Token#expiresIn} seconds. The next + * refresh task is scheduled immediately afterwards. + * + * If {@link Token#neverExpires} this method returns + * early and the next refresh task is never scheduled. + */ + private void scheduleNextRefresh() { + var t = getToken(); + if (t.neverExpires()) { + return; + } + exec.schedule(this::scheduleNextRefresh, t.expiresIn(), TimeUnit.SECONDS); + } + + @Override + public void close() throws Exception { + exec.shutdown(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/BuildInfo.java b/src/main/java/io/weaviate/client6/v1/internal/BuildInfo.java new file mode 100644 index 000000000..8ff78b9f5 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/BuildInfo.java @@ -0,0 +1,32 @@ +package io.weaviate.client6.v1.internal; + +import java.io.IOException; +import java.util.Properties; + +public final class BuildInfo { + /** Prevent public initialization. */ + private BuildInfo() { + } + + public static final String BRANCH; + public static final String COMMIT_ID; + public static final String COMMIT_ID_ABBREV; + public static final String TAGS; + + static { + var properties = new Properties(); + + try (var is = BuildInfo.class.getClassLoader().getResourceAsStream("client6-git.properties")) { + if (is != null) { + properties.load(is); + } + } catch (IOException e) { + System.out.println("failed to load client6-git.properties, no build information will be available"); + } + + BRANCH = String.valueOf(properties.getOrDefault("git.branch", "unknown")); + COMMIT_ID = String.valueOf(properties.getOrDefault("git.commit.id.full", "unknown")); + COMMIT_ID_ABBREV = String.valueOf(properties.getOrDefault("git.commit.id.abbrev", "unknown")); + TAGS = String.valueOf(properties.getOrDefault("git.tags", "unknown")); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/DateUtil.java b/src/main/java/io/weaviate/client6/v1/internal/DateUtil.java new file mode 100644 index 000000000..b103e05e7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/DateUtil.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.internal; + +import java.io.IOException; +import java.time.OffsetDateTime; + +import com.google.gson.Gson; +import com.google.gson.TypeAdapter; +import com.google.gson.TypeAdapterFactory; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +public final class DateUtil { + /** Prevent public initialization. */ + private DateUtil() { + } + + /** Convert ISO8601-formatted time string to {@link OffsetDateTime}. */ + public static OffsetDateTime fromISO8601(String iso8601) { + return OffsetDateTime.parse(iso8601); + } + + public static enum CustomTypeAdapterFactory implements TypeAdapterFactory { + INSTANCE; + + @SuppressWarnings("unchecked") + @Override + public TypeAdapter create(Gson gson, TypeToken type) { + if (type.getRawType() != OffsetDateTime.class) { + return null; + } + + return (TypeAdapter) new TypeAdapter() { + + @Override + public void write(JsonWriter out, OffsetDateTime value) throws IOException { + out.value(value.toString()); + } + + @Override + public OffsetDateTime read(JsonReader in) throws IOException { + return OffsetDateTime.parse(in.nextString()); + } + + }.nullSafe(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/Debug.java b/src/main/java/io/weaviate/client6/v1/internal/Debug.java new file mode 100644 index 000000000..87f560627 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/Debug.java @@ -0,0 +1,55 @@ +package io.weaviate.client6.v1.internal; + +import java.util.function.Consumer; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.MessageOrBuilder; +import com.google.protobuf.util.JsonFormat; + +/** Debug utilities. */ +public final class Debug { + public static final void printProto(Object proto) { + System.out.println(proto2json((MessageOrBuilder) proto)); + } + + public static final void printProto(Object proto, String message, Object... args) { + System.out.println(message.formatted(args) + ": " + proto2json((MessageOrBuilder) proto)); + } + + private static final String proto2json(MessageOrBuilder proto) { + String out; + try { + out = JsonFormat.printer().print(proto); + } catch (InvalidProtocolBufferException e) { + out = e.getMessage(); + } + + return out; + } + + /** + * Write build info to an output. See {@link #printBuildInfo}. + * + *

+ * Usage: + * + *

{@code
+   * // Log to stdout
+   * Debug.writeBuildInfo(System.out::println);
+   *
+   * // Write to custom logger
+   * Debug.writeBuildInfo(mylog::info);
+   * }
+ * + * @param writer Output writer. + */ + public static final void writeBuildInfo(Consumer writer) { + writer.accept("[io.weaviate.client6.v1.internal.BuildInfo] branch=%s commit_id=%s" + .formatted(BuildInfo.BRANCH, BuildInfo.COMMIT_ID_ABBREV)); + } + + /** Print build info to stdout. */ + public static final void printBuildInfo() { + writeBuildInfo(System.out::println); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/ExchangeTokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/ExchangeTokenProvider.java new file mode 100644 index 000000000..40bf7b66d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/ExchangeTokenProvider.java @@ -0,0 +1,37 @@ +package io.weaviate.client6.v1.internal; + +import io.weaviate.client6.v1.internal.oidc.OidcConfig; + +/** + * ExchangeTokenProvider obtains a new {@link Token} from "single-use" + * {@link TokenProvider}, usually one using an Resource Owner Password grant. + * It then creates a new internal TokenProvider to refresh the token each time + * {@link #getToken} is called. + * + *

+ * Usage: + * + *

{@code
+ * var initialGrant = TokenProvider.resourceOwnerPassword(oidc, username, password);
+ * var exchange = new ExchangeTokenProvider(oidc, initialGrant);
+ * var token = exchange.getToken();
+ * } 
+ */ +class ExchangeTokenProvider implements TokenProvider { + private final TokenProvider bearer; + + ExchangeTokenProvider(OidcConfig oidc, TokenProvider tp) { + var t = tp.getToken(); + this.bearer = TokenProvider.bearerToken(oidc, t.accessToken(), t.refreshToken(), t.expiresIn()); + } + + @Override + public Token getToken() { + return bearer.getToken(); + } + + @Override + public void close() throws Exception { + bearer.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/MapUtil.java b/src/main/java/io/weaviate/client6/v1/internal/MapUtil.java new file mode 100644 index 000000000..05811cf46 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/MapUtil.java @@ -0,0 +1,42 @@ +package io.weaviate.client6.v1.internal; + +import java.util.HashMap; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public final class MapUtil { + /** Prevent public initialization. */ + private MapUtil() { + } + + /** + * Collect stream entries into a map. Use this method whenever + * potential null keys or null values prohibit {@link Collectors#toMap}. + * + *

+ * Example: + * + *

{@code
+   * Map = MapUtil.collect(
+   *  Stream.of(1, 2, 3),
+   *  Function.identity(), // use value as key
+   *  el -> el.equals(3) ? null : el;
+   * );
+   *
+   * // Result: {1: 1, 2: 2, 3: null};
+   * }
+ * + * @param stream Stream of elements {@link T}. + * @param keyFn Transforms element {@link T} to key {@link K}. + * @param valueFn Transforms element {@link T} to value {@link V}. + * @return Map + */ + public static Map collect(Stream stream, Function keyFn, Function valueFn) { + return stream.collect( + HashMap::new, + (m, el) -> m.put(keyFn.apply(el), valueFn.apply(el)), + HashMap::putAll); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/ObjectBuilder.java b/src/main/java/io/weaviate/client6/v1/internal/ObjectBuilder.java new file mode 100644 index 000000000..b138326ea --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/ObjectBuilder.java @@ -0,0 +1,36 @@ +package io.weaviate.client6.v1.internal; + +import java.util.function.Function; + +public interface ObjectBuilder { + T build(); + + static , T> Function> identity() { + return builder -> builder; + } + + /** + * Chain two builder-functions such that {@code partialFn} is applied before + * {@code fn}. + * + *

+ * Usage: + * + *

{@code
+   *  static final Function> defaultConfig = b -> {...};
+   *  void doWithConfig(Function> fn) {
+   *    var withDefault = ObjectBuilder.partial(fn, defaultConfig);
+   *    var config = fn.apply(new Config()).build();
+   *  }
+   * }
+ * + * @param fn Function that will be applied last. + * @param partialFn Function that will be applied first. + * @return ObjectBuilder with "pre-applied" function. + */ + @SuppressWarnings("unchecked") + static , T> Function> partial(Function> fn, + Function> partialFn) { + return partialFn.andThen(b -> fn.apply((B) b)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/ReuseTokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/ReuseTokenProvider.java new file mode 100644 index 000000000..8f71580d6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/ReuseTokenProvider.java @@ -0,0 +1,92 @@ +package io.weaviate.client6.v1.internal; + +import javax.annotation.concurrent.ThreadSafe; + +/** + * ReuseTokenProvider returns the same token as long as its valid and obtains a + * new token from a {@link TokenProvider} otherwise. + * + *

+ * Usage: + * + *

{@code
+ * // Create an TokenProvider that can rotate tokens as they expire.
+ * var myProvider = new MyTokenProvider();
+ *
+ * // Create a reusable TokenProvider.
+ * var tokenProvider = ReuseTokenProvider.wrap(myProvider);
+ * }
+ */ +@ThreadSafe +final class ReuseTokenProvider implements TokenProvider { + private final TokenProvider provider; + private final long expiryDelta; + + private volatile Token token; + + /** + * Create new {@link ReuseTokenProvider} from another {@link TokenProvider}. + * Wrapping an instance ReuseTokenProvider returns that instance if the token is + * {@code null}, so this method is safe to call with any TokenProvider. + * + * @return A TokenProvider. + */ + static TokenProvider wrap(Token t, TokenProvider tp, long expiryDelta) { + if (tp instanceof ReuseTokenProvider rtp) { + if (t == null) { + // Use it directly, but set new expiry delta. + return rtp.withExpiryDelta(expiryDelta); + } + } + return new ReuseTokenProvider(t, tp, expiryDelta); + } + + /** + * Create new {@link ReuseTokenProvider} from another {@link TokenProvider}. + * Wrapping an instance ReuseTokenProvider returns that instance if the token is + * {@code null}, so this method is safe to call with any TokenProvider. + */ + static TokenProvider wrap(Token t, TokenProvider tp) { + if (tp instanceof ReuseTokenProvider rtp) { + if (t == null) { + return rtp; // Use it directly. + } + } + return new ReuseTokenProvider(t, tp, 0); + } + + /** + * Create a new TokenProvider with a different expiryDelta. + * Tokens obtained from this TokenProvider with have the same early expiry. + * + * @param expiryDelta Early expiry in seconds. + * @return A new TokenProvider. + */ + TokenProvider withExpiryDelta(long expirtyDelta) { + return new ReuseTokenProvider(this.token, this.provider, expirtyDelta); + } + + private ReuseTokenProvider(Token t, TokenProvider tp, long expiryDelta) { + this.provider = tp; + this.token = t; + this.expiryDelta = expiryDelta; + } + + @Override + public Token getToken() { + if (token != null && token.isValid()) { + return token; + } + synchronized (this) { + if (token == null || !token.isValid()) { + token = provider.getToken().withExpiryDelta(expiryDelta); + } + } + return token; + } + + @Override + public void close() throws Exception { + provider.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/TaggedUnion.java b/src/main/java/io/weaviate/client6/v1/internal/TaggedUnion.java new file mode 100644 index 000000000..42b944294 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/TaggedUnion.java @@ -0,0 +1,27 @@ +package io.weaviate.client6.v1.internal; + +public interface TaggedUnion, SelfT> { + KindT _kind(); + + SelfT _self(); + + /** Does the current instance have the kind? */ + default boolean _is(KindT kind) { + return _kind() == kind; + } + + /** Convert tagged union instance to one of its variants. */ + default > Value _as(KindT kind) { + return TaggedUnion.as(this, kind); + } + + /** Convert tagged union instance to one of its variants. */ + public static , Tag extends Enum, Value> Value as(Union union, Tag kind) { + if (union._is(kind)) { + @SuppressWarnings("unchecked") + Value value = (Value) union._self(); + return value; + } + throw new IllegalStateException("Cannot convert '%s' variant to '%s'".formatted(union._kind(), kind)); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/Timeout.java b/src/main/java/io/weaviate/client6/v1/internal/Timeout.java new file mode 100644 index 000000000..711078a3d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/Timeout.java @@ -0,0 +1,11 @@ +package io.weaviate.client6.v1.internal; + +public record Timeout(int initSeconds, int querySeconds, int insertSeconds) { + public Timeout() { + this(30, 60, 120); + } + + public Timeout(int timeout) { + this(timeout, timeout, timeout); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/TokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/TokenProvider.java new file mode 100644 index 000000000..7b28a5e7a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/TokenProvider.java @@ -0,0 +1,212 @@ +package io.weaviate.client6.v1.internal; + +import java.net.URI; +import java.time.Instant; + +import io.weaviate.client6.v1.api.WeaviateOAuthException; +import io.weaviate.client6.v1.internal.oidc.OidcConfig; +import io.weaviate.client6.v1.internal.oidc.nimbus.NimbusTokenProvider; + +/** TokenProvider obtains authentication tokens. */ +@FunctionalInterface +public interface TokenProvider extends AutoCloseable { + Token getToken(); + + /** Token represents an access_token + refresh_token pair. */ + public record Token(String accessToken, String refreshToken, Instant createdAt, long expiresIn, long expiryDelta) { + /** + * Returns {@code true} if remaining lifetime of the token is greater than 0. + * Tokens created with {@link #expireNever} are always valid. + */ + public boolean isValid() { + if (neverExpires()) { + return true; + } + return Instant.now().isBefore(createdAt.plusSeconds(expiresIn - expiryDelta)); + } + + /** Returns {@code true} if this token is always valid. */ + public boolean neverExpires() { + return expiresIn == -1; + } + + /** + * Set early expiry for the Token. + * + *

+ * A Token with {@link #expiresIn} of 10s and {@link #expiryDelta} of 3s + * will be invalid 7s after being created. + * + * @param expiryDelta Early expiry in seconds. A negative value is clamped to 0. + * @return A Token identical to the source one, but with a different expiry. + */ + public Token withExpiryDelta(long expiryDelta) { + return new Token(accessToken, refreshToken, createdAt, expiresIn, Math.max(0, expiryDelta)); + } + + /** Create a token with a different refresh_token. */ + public Token withRefreshToken(String refreshToken) { + return new Token(accessToken, refreshToken, createdAt, expiresIn, expiryDelta); + } + + /** + * Create a token with an expiration and a refresh_token. + * + * @param accessToken Access token. + * @param refreshToken Refresh token. + * @param expiresIn Remaining token lifetime in seconds. + * + * @return A new Token. + */ + public static Token expireAfter(String accessToken, String refreshToken, long expiresIn) { + return new Token(accessToken, refreshToken, Instant.now(), expiresIn, 0); + } + + /** + * Create a token that does not have a refresh_token. + * For example, a token obtained via a Client Credentials grant + * can only be renewed using that grant type. + * + * @param accessToken Access token. + * @param expiresIn Remaining token lifetime in seconds. + * + * @return A new Token. + */ + public static Token expireAfter(String accessToken, long expiresIn) { + return expireAfter(accessToken, null, expiresIn); + } + + /** + * Create a token that never expires. + * + * @param accessToken Access token. + * @return A new Token. + */ + public static Token expireNever(String accessToken) { + return Token.expireAfter(accessToken, -1); + } + } + + /** + * Refreshing the token slightly ahead of time will help prevent + * phony unauthorized access errors. + * + * This value is currently not configurable and should be seen + * as an internal implementation detail. + */ + static long DEFAULT_EARLY_EXPIRY = 30; + + /** + * Authorize using a token that never expires and doesn't need to be refreshed. + * + * @param accessToken Access token. + */ + public static TokenProvider staticToken(String accessToken) { + final var token = Token.expireNever(accessToken); + return () -> token; + } + + /** + * Create a TokenProvider that uses an existing access_token + refresh_token + * pair. + * + * @param oidc OIDC config. + * @param accessToken Access token. + * @param refreshToken Refresh token. + * @param expiresIn Remaining token lifetime in seconds. + * + * @return Internal TokenProvider implementation. + * @throws WeaviateOAuthException if an error occurred at any point of the + * exchange process. + */ + public static TokenProvider bearerToken(OidcConfig oidc, String accessToken, String refreshToken, long expiresIn) { + final var token = Token.expireAfter(accessToken, refreshToken, expiresIn); + final var provider = NimbusTokenProvider.refreshToken(oidc, token); + return background(reuse(token, provider, DEFAULT_EARLY_EXPIRY)); + } + + /** + * Create a TokenProvider that uses Resource Owner Password authorization grant. + * + * @param oidc OIDC config. + * @param username Resource owner username. + * @param password Resource owner password. + * + * @return Internal TokenProvider implementation. + * @throws WeaviateOAuthException if an error occurred at any point of the token + * exchange process. + */ + public static TokenProvider resourceOwnerPassword(OidcConfig oidc, String username, String password) { + final var passwordGrant = NimbusTokenProvider.resourceOwnerPassword(oidc, username, password); + return background(reuse(null, exchange(oidc, passwordGrant), DEFAULT_EARLY_EXPIRY)); + } + + /** + * Create a TokenProvider that uses Client Credentials authorization grant. + * + * @param oidc OIDC config. + * @param clientSecret Client secret. + * + * @return Internal TokenProvider implementation. + * @throws WeaviateOAuthException if an error occurred at any point while + * obtaining a new token. + */ + public static TokenProvider clientCredentials(OidcConfig oidc, String clientSecret) { + final var provider = NimbusTokenProvider.clientCredentials(oidc, clientSecret); + return reuse(null, provider, DEFAULT_EARLY_EXPIRY); + } + + /** + * Obtain a TokenProvider that exchanges an authorization grant for a new Token. + */ + static TokenProvider exchange(OidcConfig oidc, TokenProvider tp) { + return new ExchangeTokenProvider(oidc, tp); + } + + /** + * Obtain a TokenProvider which reuses tokens obtained + * from another TokenProvider until they expire. + */ + static TokenProvider reuse(Token t, TokenProvider tp) { + return ReuseTokenProvider.wrap(t, tp); + } + + /** + * Obtain a TokenProvider which reuses tokens obtained + * from another TokenProvider until they expire. + */ + static TokenProvider reuse(Token t, TokenProvider tp, long expiryDelta) { + return ReuseTokenProvider.wrap(t, tp, expiryDelta); + } + + /** + * Obtain a TokenProvider which refreshes tokens in a background thread. + * This ensures a refresh_token doesn't become stale. + */ + static TokenProvider background(TokenProvider tp) { + return BackgroundTokenProvider.wrap(tp); + } + + public record ProviderMetadata(URI tokenEndpoint) { + } + + /** + * Returns true if this OIDC provider's token endpoint is hosted at + * {@code login.microsoftonline.com}. + * + * @param oidc OIDC config. + * + * @throws WeaviateOAuthException if metadata could not be parsed. + */ + public static boolean isMicrosoft(OidcConfig oidc) { + var metadata = NimbusTokenProvider.parseProviderMetadata(oidc.providerMetadata()); + return metadata.tokenEndpoint().getHost().contains("login.microsoftonline.com"); + } + + /** + * Implementations which need to dispose of created resources, + * e.g. thread pools, should override this method. + */ + default void close() throws Exception { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/TransportOptions.java b/src/main/java/io/weaviate/client6/v1/internal/TransportOptions.java new file mode 100644 index 000000000..897bb28cd --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/TransportOptions.java @@ -0,0 +1,60 @@ +package io.weaviate.client6.v1.internal; + +import javax.annotation.Nullable; +import javax.net.ssl.TrustManagerFactory; + +public abstract class TransportOptions { + protected final String scheme; + protected final String host; + protected final int port; + protected final TokenProvider tokenProvider; + protected final H headers; + protected final TrustManagerFactory trustManagerFactory; + protected final Timeout timeout; + + protected TransportOptions(String scheme, String host, int port, H headers, TokenProvider tokenProvider, + TrustManagerFactory tmf, Timeout timeout) { + this.scheme = scheme; + this.host = host; + this.port = port; + this.tokenProvider = tokenProvider; + this.headers = headers; + this.timeout = timeout; + this.trustManagerFactory = tmf; + } + + public boolean isSecure() { + return scheme.equals("https"); + } + + public String scheme() { + return this.scheme; + } + + public String host() { + return this.host; + } + + public int port() { + return this.port; + } + + @Nullable + public Timeout timeout() { + return this.timeout; + } + + @Nullable + public TokenProvider tokenProvider() { + return this.tokenProvider; + } + + public H headers() { + return this.headers; + } + + @Nullable + public TrustManagerFactory trustManagerFactory() { + return this.trustManagerFactory; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/VersionSupport.java b/src/main/java/io/weaviate/client6/v1/internal/VersionSupport.java new file mode 100644 index 000000000..31927b98b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/VersionSupport.java @@ -0,0 +1,52 @@ +package io.weaviate.client6.v1.internal; + +import java.util.Arrays; + +public final class VersionSupport { + public static final SemanticVersion MINIMAL_SUPPORTED_VERSION = new SemanticVersion(1, 32); + + /** + * Returns true if the {@code version} is the same as or older than the + * {@link VersionSupport#MINIMAL_SUPPORTED_VERSION}. + */ + public static boolean isSupported(String version) { + var semver = SemanticVersion.of(version); + return semver.compareTo(MINIMAL_SUPPORTED_VERSION) >= 0; + } + + public record SemanticVersion(int major, int minor, String patch) implements Comparable { + + public SemanticVersion(int major, int minor) { + this(major, minor, null); + } + + public SemanticVersion(int major, int minor, int patch) { + this(major, minor, String.valueOf(patch)); + } + + /** + * Parse semantic version from a formatted string, + * e.g. {@code "(v)1.23.6-rc.1"}. + */ + public static SemanticVersion of(String version) { + var parts = version.replaceFirst("v", "").split("\\."); + var major = Integer.valueOf(parts[0].replaceAll("[^0-9]", "")); + var minor = Integer.valueOf(parts[1].replaceAll("[^0-9]", "")); + var patch = parts.length > 2 + ? String.join(".", Arrays.stream(parts, 2, parts.length).toList()) + : null; + return new SemanticVersion(major, minor, patch); + } + + @Override + public int compareTo(SemanticVersion that) { + var this_v = Integer.valueOf("%d%d".formatted(this.major, this.minor)); + var that_v = Integer.valueOf("%d%d".formatted(that.major, that.minor)); + return this_v.compareTo(that_v); + } + + public String toString() { + return String.join(".", String.valueOf(major), String.valueOf(minor), patch != null ? patch : "0"); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtil.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtil.java new file mode 100644 index 000000000..335c428d7 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtil.java @@ -0,0 +1,154 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.util.Arrays; +import java.util.UUID; + +import com.google.protobuf.ByteString; + +public class ByteStringUtil { + /** Prevent public initialization. */ + private ByteStringUtil() { + } + + private static final ByteOrder BYTE_ORDER = ByteOrder.LITTLE_ENDIAN; + + /** Decode ByteString to UUID. */ + public static String decodeUuid(ByteString bs) { + if (bs.size() != Long.BYTES * 2) { + return null; + } + var buf = ByteBuffer.wrap(bs.toByteArray()); + var most = buf.getLong(); + var least = buf.getLong(); + return new UUID(most, least).toString(); + } + + /** Encode float[] to ByteString. */ + public static ByteString encodeVectorSingle(float[] vector) { + if (vector == null || vector.length == 0) { + return ByteString.EMPTY; + } + ByteBuffer buffer = ByteBuffer.allocate(vector.length * Float.BYTES).order(BYTE_ORDER); + for (final var f : vector) { + buffer.putFloat(f); + } + return ByteString.copyFrom(buffer.array()); + } + + /** + * Encode float[][] to ByteString. + *

+ * The first 2 bytes of the resulting ByteString encode the number of dimensions + * (uint16 / short) followed by concatenated vectors (4 bytes per element). + */ + public static ByteString encodeVectorMulti(float[][] vectors) { + if (vectors == null || vectors.length == 0 || vectors[0].length == 0) { + return ByteString.EMPTY; + } + + int n = vectors.length; + short dimensions = (short) vectors[0].length; + int capacity = /* vector dimensions */ Short.BYTES + + /* concatenated elements */ (n * dimensions * Float.BYTES); + ByteBuffer buffer = ByteBuffer.allocate(capacity).order(BYTE_ORDER) + .putShort(dimensions); + Arrays.stream(vectors).forEach(vector -> { + for (final var f : vector) { + buffer.putFloat(f); + } + }); + return ByteString.copyFrom(buffer.array()); + } + + /** + * Decode ByteString to {@code float[]}. + * + * @throws IllegalArgumentException if ByteString size is not + * a multiple of {@link Float#BYTES}. + */ + public static float[] decodeVectorSingle(ByteString bs) { + if (bs.size() % Float.BYTES != 0) { + throw new IllegalArgumentException( + "ByteString size " + bs.size() + " is not a multiple of " + String.valueOf(Float.BYTES) + " (Float.BYTES)"); + } + float[] vector = new float[bs.size() / Float.BYTES]; + bs.asReadOnlyByteBuffer().order(BYTE_ORDER).asFloatBuffer().get(vector); + return vector; + } + + /** + * Decode ByteString to {@code float[][]}. + * + *

+ * The expected structure of the byte string of total size N is: + *

    + *
  • [2 bytes]: dimensionality of the inner vector ({@code dim}) + *
  • [N-2 bytes]: concatenated inner vectors. N-2 must be a multiple of + * {@code Float.BYTES * dim} + *
+ * + * @throws IllegalArgumentException if ByteString is not of a valid size. + */ + public static float[][] decodeVectorMulti(ByteString bs) { + if (bs == null || bs.size() == 0) { + return new float[0][0]; + } + + ByteBuffer buf = bs.asReadOnlyByteBuffer().order(BYTE_ORDER); + short dim = buf.getShort(); // advances current position + if (dim == 0) { + return new float[0][0]; + } + + FloatBuffer fbuf = buf.asFloatBuffer(); // fbuf size is buf / Float.BYTES + if (fbuf.remaining() % dim != 0) { + throw new IllegalArgumentException( + "Remaing ByteString size " + fbuf.remaining() + " is not a multiple of " + dim + + " (dim)"); + } + int n = fbuf.remaining() / dim; + + // Reading from buffer advances current position, + // so we always read from offset=0. + float[][] vectors = new float[n][dim]; + for (int i = 0; i < n; i++) { + fbuf.get(vectors[i], 0, dim); + } + return vectors; + } + + /** + * Decode ByteString to {@code long[]}. + * + * @throws IllegalArgumentException if ByteString size is not + * a multiple of {@link Long#BYTES}. + */ + public static long[] decodeIntValues(ByteString bs) { + if (bs.size() % Long.BYTES != 0) { + throw new IllegalArgumentException( + "ByteString size " + bs.size() + " is not a multiple of " + String.valueOf(Long.BYTES) + " (Long.BYTES)"); + } + long[] vector = new long[bs.size() / Long.BYTES]; + bs.asReadOnlyByteBuffer().order(BYTE_ORDER).asLongBuffer().get(vector); + return vector; + } + + /** + * Decode ByteString to {@code double[]}. + * + * @throws IllegalArgumentException if ByteString size is not + * a multiple of {@link Double#BYTES}. + */ + public static double[] decodeNumberValues(ByteString bs) { + if (bs.size() % Double.BYTES != 0) { + throw new IllegalArgumentException( + "ByteString size " + bs.size() + " is not a multiple of " + String.valueOf(Double.BYTES) + " (Double.BYTES)"); + } + double[] vector = new double[bs.size() / Double.BYTES]; + bs.asReadOnlyByteBuffer().order(BYTE_ORDER).asDoubleBuffer().get(vector); + return vector; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/DefaultGrpcTransport.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/DefaultGrpcTransport.java new file mode 100644 index 000000000..d12255d22 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/DefaultGrpcTransport.java @@ -0,0 +1,154 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; + +import javax.net.ssl.SSLException; + +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; + +import io.grpc.ManagedChannel; +import io.grpc.StatusRuntimeException; +import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts; +import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder; +import io.grpc.netty.shaded.io.netty.handler.ssl.SslContext; +import io.grpc.stub.AbstractStub; +import io.grpc.stub.MetadataUtils; +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; + +public final class DefaultGrpcTransport implements GrpcTransport { + private final ManagedChannel channel; + + private final WeaviateBlockingStub blockingStub; + private final WeaviateFutureStub futureStub; + + private final GrpcChannelOptions transportOptions; + + private TokenCallCredentials callCredentials; + + public DefaultGrpcTransport(GrpcChannelOptions transportOptions) { + this.transportOptions = transportOptions; + this.channel = buildChannel(transportOptions); + + var blockingStub = WeaviateGrpc.newBlockingStub(channel) + .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(transportOptions.headers())); + + var futureStub = WeaviateGrpc.newFutureStub(channel) + .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(transportOptions.headers())); + + if (transportOptions.maxMessageSize() != null) { + var max = transportOptions.maxMessageSize(); + blockingStub = blockingStub.withMaxInboundMessageSize(max).withMaxOutboundMessageSize(max); + futureStub = futureStub.withMaxInboundMessageSize(max).withMaxOutboundMessageSize(max); + } + + if (transportOptions.tokenProvider() != null) { + this.callCredentials = new TokenCallCredentials(transportOptions.tokenProvider()); + blockingStub = blockingStub.withCallCredentials(callCredentials); + futureStub = futureStub.withCallCredentials(callCredentials); + } + + this.blockingStub = blockingStub; + this.futureStub = futureStub; + } + + private > StubT applyTimeout(StubT stub, Rpc rpc) { + if (transportOptions.timeout() == null) { + return stub; + } + var timeout = rpc.isInsert() + ? transportOptions.timeout().insertSeconds() + : transportOptions.timeout().querySeconds(); + return stub.withDeadlineAfter(timeout, TimeUnit.SECONDS); + } + + @Override + public ResponseT performRequest(RequestT request, + Rpc rpc) { + var message = rpc.marshal(request); + var method = rpc.method(); + var stub = applyTimeout(blockingStub, rpc); + try { + var reply = method.apply(stub, message); + return rpc.unmarshal(reply); + } catch (io.grpc.StatusRuntimeException e) { + throw WeaviateApiException.gRPC(e); + } + } + + @Override + public CompletableFuture performRequestAsync(RequestT request, + Rpc rpc) { + var message = rpc.marshal(request); + var method = rpc.methodAsync(); + var stub = applyTimeout(futureStub, rpc); + var reply = method.apply(stub, message); + return toCompletableFuture(reply).thenApply(r -> rpc.unmarshal(r)); + } + + /** + * Convets {@link ListenableFuture} to {@link CompletableFuture} + * reusing the thread in which the original future is completed. + */ + private static final CompletableFuture toCompletableFuture(ListenableFuture listenable) { + var completable = new CompletableFuture(); + Futures.addCallback(listenable, new FutureCallback() { + + @Override + public void onSuccess(T result) { + completable.complete(result); + } + + @Override + public void onFailure(Throwable t) { + if (t instanceof StatusRuntimeException e) { + completable.completeExceptionally(WeaviateApiException.gRPC(e)); + return; + } + completable.completeExceptionally(t); + } + + }, Runnable::run); + return completable; + } + + private static ManagedChannel buildChannel(GrpcChannelOptions transportOptions) { + var channel = NettyChannelBuilder.forAddress(transportOptions.host(), transportOptions.port()); + + if (transportOptions.isSecure()) { + channel.useTransportSecurity(); + } else { + channel.usePlaintext(); + } + + if (transportOptions.trustManagerFactory() != null) { + SslContext sslCtx; + try { + sslCtx = GrpcSslContexts.forClient() + .trustManager(transportOptions.trustManagerFactory()) + .build(); + } catch (SSLException e) { + // todo: rethrow as WeaviateConnectionException + throw new RuntimeException("create grpc transport", e); + } + channel.sslContext(sslCtx); + } + + channel.intercept(MetadataUtils.newAttachHeadersInterceptor(transportOptions.headers())); + + return channel.build(); + } + + @Override + public void close() throws Exception { + channel.shutdown(); + if (callCredentials != null) { + callCredentials.close(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcChannelOptions.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcChannelOptions.java new file mode 100644 index 000000000..5e4453d7f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcChannelOptions.java @@ -0,0 +1,44 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.Map; + +import javax.net.ssl.TrustManagerFactory; + +import io.grpc.Metadata; +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.TransportOptions; + +public class GrpcChannelOptions extends TransportOptions { + private final Integer maxMessageSize; + + public GrpcChannelOptions(String scheme, String host, int port, Map headers, + TokenProvider tokenProvider, TrustManagerFactory tmf, Timeout timeout) { + this(scheme, host, port, buildMetadata(headers), tokenProvider, tmf, null, timeout); + } + + private GrpcChannelOptions(String scheme, String host, int port, Metadata headers, + TokenProvider tokenProvider, TrustManagerFactory tmf, Integer maxMessageSize, Timeout timeout) { + super(scheme, host, port, headers, tokenProvider, tmf, timeout); + this.maxMessageSize = maxMessageSize; + } + + public GrpcChannelOptions withMaxMessageSize(int maxMessageSize) { + return new GrpcChannelOptions(scheme, host, port, headers, tokenProvider, trustManagerFactory, maxMessageSize, + timeout); + } + + public Integer maxMessageSize() { + return maxMessageSize; + } + + private static final Metadata buildMetadata(Map headers) { + var metadata = new Metadata(); + for (var header : headers.entrySet()) { + metadata.put( + Metadata.Key.of(header.getKey(), Metadata.ASCII_STRING_MARSHALLER), + header.getValue()); + } + return metadata; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcTransport.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcTransport.java new file mode 100644 index 000000000..cad58257b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/GrpcTransport.java @@ -0,0 +1,11 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.concurrent.CompletableFuture; + +public interface GrpcTransport extends AutoCloseable { + ResponseT performRequest(RequestT request, + Rpc rpc); + + CompletableFuture performRequestAsync(RequestT request, + Rpc rpc); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/Rpc.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/Rpc.java new file mode 100644 index 000000000..8bf863b78 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/Rpc.java @@ -0,0 +1,40 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; + +import com.google.common.util.concurrent.ListenableFuture; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; + +public interface Rpc { + RequestM marshal(RequestT request); + + ResponseT unmarshal(ReplyM reply); + + BiFunction method(); + + BiFunction> methodAsync(); + + default boolean isInsert() { + return false; + } + + public static SimpleRpc of( + Function marshal, + Function unmarshal, + Supplier> method, + Supplier>> methodAsync) { + return new SimpleRpc<>(marshal, unmarshal, method, methodAsync, false); + } + + public static SimpleRpc insert( + Function marshal, + Function unmarshal, + Supplier> method, + Supplier>> methodAsync) { + return new SimpleRpc<>(marshal, unmarshal, method, methodAsync, true); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/SimpleRpc.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/SimpleRpc.java new file mode 100644 index 000000000..ebde06dee --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/SimpleRpc.java @@ -0,0 +1,56 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Supplier; + +import com.google.common.util.concurrent.ListenableFuture; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub; + +public class SimpleRpc implements Rpc { + + private final boolean isInsert; + + private final Function marshal; + private final Function unmarshal; + private final Supplier> method; + private final Supplier>> methodAsync; + + SimpleRpc(Function marshal, Function unmarshal, + Supplier> method, + Supplier>> methodAsync, + boolean isInsert) { + this.marshal = marshal; + this.unmarshal = unmarshal; + this.method = method; + this.methodAsync = methodAsync; + this.isInsert = isInsert; + } + + @Override + public RequestM marshal(RequestT request) { + return marshal.apply(request); + } + + @Override + public ResponseT unmarshal(ReplyM reply) { + return unmarshal.apply(reply); + } + + @Override + public BiFunction method() { + return method.get(); + } + + @Override + public BiFunction> methodAsync() { + return methodAsync.get(); + } + + @Override + public boolean isInsert() { + return isInsert; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/TokenCallCredentials.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/TokenCallCredentials.java new file mode 100644 index 000000000..c69696682 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/TokenCallCredentials.java @@ -0,0 +1,44 @@ +package io.weaviate.client6.v1.internal.grpc; + +import java.util.concurrent.Executor; + +import io.grpc.CallCredentials; +import io.grpc.Metadata; +import io.grpc.Status; +import io.weaviate.client6.v1.internal.AsyncTokenProvider; +import io.weaviate.client6.v1.internal.TokenProvider; + +class TokenCallCredentials extends CallCredentials implements AutoCloseable { + private static final Metadata.Key AUTHORIZATION = Metadata.Key.of("Authorization", + Metadata.ASCII_STRING_MARSHALLER); + + /** + * Since {@link #applyRequestMetadata} accepts an {@link Executor} anyways, + * we can always just use an async provider, instead of creating 2 separate + * instances for it. + */ + private final AsyncTokenProvider tokenProviderAsync; + + TokenCallCredentials(TokenProvider tokenProvider) { + this.tokenProviderAsync = AsyncTokenProvider.wrap(tokenProvider); + } + + @Override + public void applyRequestMetadata(RequestInfo requestInfo, Executor executor, MetadataApplier metadataApplier) { + tokenProviderAsync.getToken(executor) + .whenComplete((tok, ex) -> { + if (ex != null) { + metadataApplier.fail(Status.UNAUTHENTICATED.withCause(ex)); + return; + } + var headers = new Metadata(); + headers.put(AUTHORIZATION, "Bearer " + tok.accessToken()); + metadataApplier.apply(headers); + }); + } + + @Override + public void close() throws Exception { + tokenProviderAsync.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/WeaviateObjectTypeAdapter.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/WeaviateObjectTypeAdapter.java new file mode 100644 index 000000000..e69de29bb diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/FileReplicationServiceGrpc.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/FileReplicationServiceGrpc.java new file mode 100644 index 000000000..1db25a027 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/FileReplicationServiceGrpc.java @@ -0,0 +1,557 @@ +package io.weaviate.client6.v1.internal.grpc.protocol; + +import static io.grpc.MethodDescriptor.generateFullMethodName; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler (version 1.58.0)", + comments = "Source: v1/file_replication.proto") +@io.grpc.stub.annotations.GrpcGenerated +public final class FileReplicationServiceGrpc { + + private FileReplicationServiceGrpc() {} + + public static final java.lang.String SERVICE_NAME = "weaviate.v1.FileReplicationService"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getPauseFileActivityMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "PauseFileActivity", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getPauseFileActivityMethod() { + io.grpc.MethodDescriptor getPauseFileActivityMethod; + if ((getPauseFileActivityMethod = FileReplicationServiceGrpc.getPauseFileActivityMethod) == null) { + synchronized (FileReplicationServiceGrpc.class) { + if ((getPauseFileActivityMethod = FileReplicationServiceGrpc.getPauseFileActivityMethod) == null) { + FileReplicationServiceGrpc.getPauseFileActivityMethod = getPauseFileActivityMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PauseFileActivity")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.getDefaultInstance())) + .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("PauseFileActivity")) + .build(); + } + } + } + return getPauseFileActivityMethod; + } + + private static volatile io.grpc.MethodDescriptor getResumeFileActivityMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "ResumeFileActivity", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getResumeFileActivityMethod() { + io.grpc.MethodDescriptor getResumeFileActivityMethod; + if ((getResumeFileActivityMethod = FileReplicationServiceGrpc.getResumeFileActivityMethod) == null) { + synchronized (FileReplicationServiceGrpc.class) { + if ((getResumeFileActivityMethod = FileReplicationServiceGrpc.getResumeFileActivityMethod) == null) { + FileReplicationServiceGrpc.getResumeFileActivityMethod = getResumeFileActivityMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResumeFileActivity")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.getDefaultInstance())) + .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("ResumeFileActivity")) + .build(); + } + } + } + return getResumeFileActivityMethod; + } + + private static volatile io.grpc.MethodDescriptor getListFilesMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "ListFiles", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getListFilesMethod() { + io.grpc.MethodDescriptor getListFilesMethod; + if ((getListFilesMethod = FileReplicationServiceGrpc.getListFilesMethod) == null) { + synchronized (FileReplicationServiceGrpc.class) { + if ((getListFilesMethod = FileReplicationServiceGrpc.getListFilesMethod) == null) { + FileReplicationServiceGrpc.getListFilesMethod = getListFilesMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListFiles")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.getDefaultInstance())) + .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("ListFiles")) + .build(); + } + } + } + return getListFilesMethod; + } + + private static volatile io.grpc.MethodDescriptor getGetFileMetadataMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetFileMetadata", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getGetFileMetadataMethod() { + io.grpc.MethodDescriptor getGetFileMetadataMethod; + if ((getGetFileMetadataMethod = FileReplicationServiceGrpc.getGetFileMetadataMethod) == null) { + synchronized (FileReplicationServiceGrpc.class) { + if ((getGetFileMetadataMethod = FileReplicationServiceGrpc.getGetFileMetadataMethod) == null) { + FileReplicationServiceGrpc.getGetFileMetadataMethod = getGetFileMetadataMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetFileMetadata")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.getDefaultInstance())) + .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("GetFileMetadata")) + .build(); + } + } + } + return getGetFileMetadataMethod; + } + + private static volatile io.grpc.MethodDescriptor getGetFileMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "GetFile", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.class, + methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + public static io.grpc.MethodDescriptor getGetFileMethod() { + io.grpc.MethodDescriptor getGetFileMethod; + if ((getGetFileMethod = FileReplicationServiceGrpc.getGetFileMethod) == null) { + synchronized (FileReplicationServiceGrpc.class) { + if ((getGetFileMethod = FileReplicationServiceGrpc.getGetFileMethod) == null) { + FileReplicationServiceGrpc.getGetFileMethod = getGetFileMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetFile")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.getDefaultInstance())) + .setSchemaDescriptor(new FileReplicationServiceMethodDescriptorSupplier("GetFile")) + .build(); + } + } + } + return getGetFileMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static FileReplicationServiceStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public FileReplicationServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceStub(channel, callOptions); + } + }; + return FileReplicationServiceStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static FileReplicationServiceBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public FileReplicationServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceBlockingStub(channel, callOptions); + } + }; + return FileReplicationServiceBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static FileReplicationServiceFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public FileReplicationServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceFutureStub(channel, callOptions); + } + }; + return FileReplicationServiceFutureStub.newStub(factory, channel); + } + + /** + */ + public interface AsyncService { + + /** + */ + default void pauseFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPauseFileActivityMethod(), responseObserver); + } + + /** + */ + default void resumeFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumeFileActivityMethod(), responseObserver); + } + + /** + */ + default void listFiles(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListFilesMethod(), responseObserver); + } + + /** + */ + default io.grpc.stub.StreamObserver getFileMetadata( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getGetFileMetadataMethod(), responseObserver); + } + + /** + */ + default io.grpc.stub.StreamObserver getFile( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getGetFileMethod(), responseObserver); + } + } + + /** + * Base class for the server implementation of the service FileReplicationService. + */ + public static abstract class FileReplicationServiceImplBase + implements io.grpc.BindableService, AsyncService { + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return FileReplicationServiceGrpc.bindService(this); + } + } + + /** + * A stub to allow clients to do asynchronous rpc calls to service FileReplicationService. + */ + public static final class FileReplicationServiceStub + extends io.grpc.stub.AbstractAsyncStub { + private FileReplicationServiceStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected FileReplicationServiceStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceStub(channel, callOptions); + } + + /** + */ + public void pauseFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getPauseFileActivityMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void resumeFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getResumeFileActivityMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void listFiles(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getListFilesMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public io.grpc.stub.StreamObserver getFileMetadata( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ClientCalls.asyncBidiStreamingCall( + getChannel().newCall(getGetFileMetadataMethod(), getCallOptions()), responseObserver); + } + + /** + */ + public io.grpc.stub.StreamObserver getFile( + io.grpc.stub.StreamObserver responseObserver) { + return io.grpc.stub.ClientCalls.asyncBidiStreamingCall( + getChannel().newCall(getGetFileMethod(), getCallOptions()), responseObserver); + } + } + + /** + * A stub to allow clients to do synchronous rpc calls to service FileReplicationService. + */ + public static final class FileReplicationServiceBlockingStub + extends io.grpc.stub.AbstractBlockingStub { + private FileReplicationServiceBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected FileReplicationServiceBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceBlockingStub(channel, callOptions); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse pauseFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getPauseFileActivityMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse resumeFileActivity(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getResumeFileActivityMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse listFiles(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getListFilesMethod(), getCallOptions(), request); + } + } + + /** + * A stub to allow clients to do ListenableFuture-style rpc calls to service FileReplicationService. + */ + public static final class FileReplicationServiceFutureStub + extends io.grpc.stub.AbstractFutureStub { + private FileReplicationServiceFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected FileReplicationServiceFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new FileReplicationServiceFutureStub(channel, callOptions); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture pauseFileActivity( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getPauseFileActivityMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture resumeFileActivity( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getResumeFileActivityMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture listFiles( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getListFilesMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_PAUSE_FILE_ACTIVITY = 0; + private static final int METHODID_RESUME_FILE_ACTIVITY = 1; + private static final int METHODID_LIST_FILES = 2; + private static final int METHODID_GET_FILE_METADATA = 3; + private static final int METHODID_GET_FILE = 4; + + 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 AsyncService serviceImpl; + private final int methodId; + + MethodHandlers(AsyncService 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_PAUSE_FILE_ACTIVITY: + serviceImpl.pauseFileActivity((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_RESUME_FILE_ACTIVITY: + serviceImpl.resumeFileActivity((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_LIST_FILES: + serviceImpl.listFiles((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest) 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_GET_FILE_METADATA: + return (io.grpc.stub.StreamObserver) serviceImpl.getFileMetadata( + (io.grpc.stub.StreamObserver) responseObserver); + case METHODID_GET_FILE: + return (io.grpc.stub.StreamObserver) serviceImpl.getFile( + (io.grpc.stub.StreamObserver) responseObserver); + default: + throw new AssertionError(); + } + } + } + + public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getPauseFileActivityMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse>( + service, METHODID_PAUSE_FILE_ACTIVITY))) + .addMethod( + getResumeFileActivityMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse>( + service, METHODID_RESUME_FILE_ACTIVITY))) + .addMethod( + getListFilesMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse>( + service, METHODID_LIST_FILES))) + .addMethod( + getGetFileMetadataMethod(), + io.grpc.stub.ServerCalls.asyncBidiStreamingCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata>( + service, METHODID_GET_FILE_METADATA))) + .addMethod( + getGetFileMethod(), + io.grpc.stub.ServerCalls.asyncBidiStreamingCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk>( + service, METHODID_GET_FILE))) + .build(); + } + + private static abstract class FileReplicationServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { + FileReplicationServiceBaseDescriptorSupplier() {} + + @java.lang.Override + public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.getDescriptor(); + } + + @java.lang.Override + public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { + return getFileDescriptor().findServiceByName("FileReplicationService"); + } + } + + private static final class FileReplicationServiceFileDescriptorSupplier + extends FileReplicationServiceBaseDescriptorSupplier { + FileReplicationServiceFileDescriptorSupplier() {} + } + + private static final class FileReplicationServiceMethodDescriptorSupplier + extends FileReplicationServiceBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { + private final java.lang.String methodName; + + FileReplicationServiceMethodDescriptorSupplier(java.lang.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 (FileReplicationServiceGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .setSchemaDescriptor(new FileReplicationServiceFileDescriptorSupplier()) + .addMethod(getPauseFileActivityMethod()) + .addMethod(getResumeFileActivityMethod()) + .addMethod(getListFilesMethod()) + .addMethod(getGetFileMetadataMethod()) + .addMethod(getGetFileMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateGrpc.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateGrpc.java new file mode 100644 index 000000000..1813f2c4c --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateGrpc.java @@ -0,0 +1,804 @@ +package io.weaviate.client6.v1.internal.grpc.protocol; + +import static io.grpc.MethodDescriptor.generateFullMethodName; + +/** + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler (version 1.58.0)", + comments = "Source: v1/weaviate.proto") +@io.grpc.stub.annotations.GrpcGenerated +public final class WeaviateGrpc { + + private WeaviateGrpc() {} + + public static final java.lang.String SERVICE_NAME = "weaviate.v1.Weaviate"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor getSearchMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Search", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getSearchMethod() { + io.grpc.MethodDescriptor getSearchMethod; + if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getSearchMethod = WeaviateGrpc.getSearchMethod) == null) { + WeaviateGrpc.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( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("Search")) + .build(); + } + } + } + return getSearchMethod; + } + + private static volatile io.grpc.MethodDescriptor getBatchObjectsMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "BatchObjects", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getBatchObjectsMethod() { + io.grpc.MethodDescriptor getBatchObjectsMethod; + if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getBatchObjectsMethod = WeaviateGrpc.getBatchObjectsMethod) == null) { + WeaviateGrpc.getBatchObjectsMethod = getBatchObjectsMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchObjects")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchObjects")) + .build(); + } + } + } + return getBatchObjectsMethod; + } + + private static volatile io.grpc.MethodDescriptor getBatchReferencesMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "BatchReferences", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getBatchReferencesMethod() { + io.grpc.MethodDescriptor getBatchReferencesMethod; + if ((getBatchReferencesMethod = WeaviateGrpc.getBatchReferencesMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getBatchReferencesMethod = WeaviateGrpc.getBatchReferencesMethod) == null) { + WeaviateGrpc.getBatchReferencesMethod = getBatchReferencesMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchReferences")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchReferences")) + .build(); + } + } + } + return getBatchReferencesMethod; + } + + private static volatile io.grpc.MethodDescriptor getBatchDeleteMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "BatchDelete", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getBatchDeleteMethod() { + io.grpc.MethodDescriptor getBatchDeleteMethod; + if ((getBatchDeleteMethod = WeaviateGrpc.getBatchDeleteMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getBatchDeleteMethod = WeaviateGrpc.getBatchDeleteMethod) == null) { + WeaviateGrpc.getBatchDeleteMethod = getBatchDeleteMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchDelete")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchDelete")) + .build(); + } + } + } + return getBatchDeleteMethod; + } + + private static volatile io.grpc.MethodDescriptor getTenantsGetMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "TenantsGet", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getTenantsGetMethod() { + io.grpc.MethodDescriptor getTenantsGetMethod; + if ((getTenantsGetMethod = WeaviateGrpc.getTenantsGetMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getTenantsGetMethod = WeaviateGrpc.getTenantsGetMethod) == null) { + WeaviateGrpc.getTenantsGetMethod = getTenantsGetMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "TenantsGet")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("TenantsGet")) + .build(); + } + } + } + return getTenantsGetMethod; + } + + private static volatile io.grpc.MethodDescriptor getAggregateMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "Aggregate", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getAggregateMethod() { + io.grpc.MethodDescriptor getAggregateMethod; + if ((getAggregateMethod = WeaviateGrpc.getAggregateMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getAggregateMethod = WeaviateGrpc.getAggregateMethod) == null) { + WeaviateGrpc.getAggregateMethod = getAggregateMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Aggregate")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("Aggregate")) + .build(); + } + } + } + return getAggregateMethod; + } + + private static volatile io.grpc.MethodDescriptor getBatchSendMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "BatchSend", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor getBatchSendMethod() { + io.grpc.MethodDescriptor getBatchSendMethod; + if ((getBatchSendMethod = WeaviateGrpc.getBatchSendMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getBatchSendMethod = WeaviateGrpc.getBatchSendMethod) == null) { + WeaviateGrpc.getBatchSendMethod = getBatchSendMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchSend")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchSend")) + .build(); + } + } + } + return getBatchSendMethod; + } + + private static volatile io.grpc.MethodDescriptor getBatchStreamMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "BatchStream", + requestType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.class, + responseType = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.class, + methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + public static io.grpc.MethodDescriptor getBatchStreamMethod() { + io.grpc.MethodDescriptor getBatchStreamMethod; + if ((getBatchStreamMethod = WeaviateGrpc.getBatchStreamMethod) == null) { + synchronized (WeaviateGrpc.class) { + if ((getBatchStreamMethod = WeaviateGrpc.getBatchStreamMethod) == null) { + WeaviateGrpc.getBatchStreamMethod = getBatchStreamMethod = + io.grpc.MethodDescriptor.newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BatchStream")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance())) + .setSchemaDescriptor(new WeaviateMethodDescriptorSupplier("BatchStream")) + .build(); + } + } + } + return getBatchStreamMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static WeaviateStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public WeaviateStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateStub(channel, callOptions); + } + }; + return WeaviateStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static WeaviateBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public WeaviateBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateBlockingStub(channel, callOptions); + } + }; + return WeaviateBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static WeaviateFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory factory = + new io.grpc.stub.AbstractStub.StubFactory() { + @java.lang.Override + public WeaviateFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateFutureStub(channel, callOptions); + } + }; + return WeaviateFutureStub.newStub(factory, channel); + } + + /** + */ + public interface AsyncService { + + /** + */ + default void search(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSearchMethod(), responseObserver); + } + + /** + */ + default void batchObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchObjectsMethod(), responseObserver); + } + + /** + */ + default void batchReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchReferencesMethod(), responseObserver); + } + + /** + */ + default void batchDelete(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchDeleteMethod(), responseObserver); + } + + /** + */ + default void tenantsGet(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getTenantsGetMethod(), responseObserver); + } + + /** + */ + default void aggregate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAggregateMethod(), responseObserver); + } + + /** + */ + default void batchSend(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchSendMethod(), responseObserver); + } + + /** + */ + default void batchStream(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBatchStreamMethod(), responseObserver); + } + } + + /** + * Base class for the server implementation of the service Weaviate. + */ + public static abstract class WeaviateImplBase + implements io.grpc.BindableService, AsyncService { + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return WeaviateGrpc.bindService(this); + } + } + + /** + * A stub to allow clients to do asynchronous rpc calls to service Weaviate. + */ + public static final class WeaviateStub + extends io.grpc.stub.AbstractAsyncStub { + private WeaviateStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected WeaviateStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateStub(channel, callOptions); + } + + /** + */ + public void search(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getSearchMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void batchObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void batchReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getBatchReferencesMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void batchDelete(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getBatchDeleteMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void tenantsGet(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getTenantsGetMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void aggregate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getAggregateMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void batchSend(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getBatchSendMethod(), getCallOptions()), request, responseObserver); + } + + /** + */ + public void batchStream(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest request, + io.grpc.stub.StreamObserver responseObserver) { + io.grpc.stub.ClientCalls.asyncServerStreamingCall( + getChannel().newCall(getBatchStreamMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * A stub to allow clients to do synchronous rpc calls to service Weaviate. + */ + public static final class WeaviateBlockingStub + extends io.grpc.stub.AbstractBlockingStub { + private WeaviateBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected WeaviateBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateBlockingStub(channel, callOptions); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply search(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getSearchMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply batchObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getBatchObjectsMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply batchReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getBatchReferencesMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply batchDelete(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getBatchDeleteMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply tenantsGet(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getTenantsGetMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply aggregate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getAggregateMethod(), getCallOptions(), request); + } + + /** + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply batchSend(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getBatchSendMethod(), getCallOptions(), request); + } + + /** + */ + public java.util.Iterator batchStream( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest request) { + return io.grpc.stub.ClientCalls.blockingServerStreamingCall( + getChannel(), getBatchStreamMethod(), getCallOptions(), request); + } + } + + /** + * A stub to allow clients to do ListenableFuture-style rpc calls to service Weaviate. + */ + public static final class WeaviateFutureStub + extends io.grpc.stub.AbstractFutureStub { + private WeaviateFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected WeaviateFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new WeaviateFutureStub(channel, callOptions); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture search( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getSearchMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture batchObjects( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getBatchObjectsMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture batchReferences( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getBatchReferencesMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture batchDelete( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getBatchDeleteMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture tenantsGet( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getTenantsGetMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture aggregate( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getAggregateMethod(), getCallOptions()), request); + } + + /** + */ + public com.google.common.util.concurrent.ListenableFuture batchSend( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getBatchSendMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_SEARCH = 0; + private static final int METHODID_BATCH_OBJECTS = 1; + private static final int METHODID_BATCH_REFERENCES = 2; + private static final int METHODID_BATCH_DELETE = 3; + private static final int METHODID_TENANTS_GET = 4; + private static final int METHODID_AGGREGATE = 5; + private static final int METHODID_BATCH_SEND = 6; + private static final int METHODID_BATCH_STREAM = 7; + + 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 AsyncService serviceImpl; + private final int methodId; + + MethodHandlers(AsyncService 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_SEARCH: + serviceImpl.search((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_BATCH_OBJECTS: + serviceImpl.batchObjects((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_BATCH_REFERENCES: + serviceImpl.batchReferences((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_BATCH_DELETE: + serviceImpl.batchDelete((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_TENANTS_GET: + serviceImpl.tenantsGet((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_AGGREGATE: + serviceImpl.aggregate((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_BATCH_SEND: + serviceImpl.batchSend((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest) request, + (io.grpc.stub.StreamObserver) responseObserver); + break; + case METHODID_BATCH_STREAM: + serviceImpl.batchStream((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest) 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(); + } + } + } + + public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getSearchMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply>( + service, METHODID_SEARCH))) + .addMethod( + getBatchObjectsMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply>( + service, METHODID_BATCH_OBJECTS))) + .addMethod( + getBatchReferencesMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply>( + service, METHODID_BATCH_REFERENCES))) + .addMethod( + getBatchDeleteMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply>( + service, METHODID_BATCH_DELETE))) + .addMethod( + getTenantsGetMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply>( + service, METHODID_TENANTS_GET))) + .addMethod( + getAggregateMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply>( + service, METHODID_AGGREGATE))) + .addMethod( + getBatchSendMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply>( + service, METHODID_BATCH_SEND))) + .addMethod( + getBatchStreamMethod(), + io.grpc.stub.ServerCalls.asyncServerStreamingCall( + new MethodHandlers< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage>( + service, METHODID_BATCH_STREAM))) + .build(); + } + + private static abstract class WeaviateBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { + WeaviateBaseDescriptorSupplier() {} + + @java.lang.Override + public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProto.getDescriptor(); + } + + @java.lang.Override + public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { + return getFileDescriptor().findServiceByName("Weaviate"); + } + } + + private static final class WeaviateFileDescriptorSupplier + extends WeaviateBaseDescriptorSupplier { + WeaviateFileDescriptorSupplier() {} + } + + private static final class WeaviateMethodDescriptorSupplier + extends WeaviateBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { + private final java.lang.String methodName; + + WeaviateMethodDescriptorSupplier(java.lang.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 (WeaviateGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .setSchemaDescriptor(new WeaviateFileDescriptorSupplier()) + .addMethod(getSearchMethod()) + .addMethod(getBatchObjectsMethod()) + .addMethod(getBatchReferencesMethod()) + .addMethod(getBatchDeleteMethod()) + .addMethod(getTenantsGetMethod()) + .addMethod(getAggregateMethod()) + .addMethod(getBatchSendMethod()) + .addMethod(getBatchStreamMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProto.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProto.java new file mode 100644 index 000000000..688c1e769 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProto.java @@ -0,0 +1,66 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: v1/weaviate.proto + +package io.weaviate.client6.v1.internal.grpc.protocol; + +public final class WeaviateProto { + private WeaviateProto() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\021v1/weaviate.proto\022\013weaviate.v1\032\022v1/agg" + + "regate.proto\032\016v1/batch.proto\032\025v1/batch_d" + + "elete.proto\032\023v1/search_get.proto\032\020v1/ten" + + "ants.proto2\207\005\n\010Weaviate\022@\n\006Search\022\032.weav" + + "iate.v1.SearchRequest\032\030.weaviate.v1.Sear" + + "chReply\"\000\022R\n\014BatchObjects\022 .weaviate.v1." + + "BatchObjectsRequest\032\036.weaviate.v1.BatchO" + + "bjectsReply\"\000\022[\n\017BatchReferences\022#.weavi" + + "ate.v1.BatchReferencesRequest\032!.weaviate" + + ".v1.BatchReferencesReply\"\000\022O\n\013BatchDelet" + + "e\022\037.weaviate.v1.BatchDeleteRequest\032\035.wea" + + "viate.v1.BatchDeleteReply\"\000\022L\n\nTenantsGe" + + "t\022\036.weaviate.v1.TenantsGetRequest\032\034.weav" + + "iate.v1.TenantsGetReply\"\000\022I\n\tAggregate\022\035" + + ".weaviate.v1.AggregateRequest\032\033.weaviate" + + ".v1.AggregateReply\"\000\022I\n\tBatchSend\022\035.weav" + + "iate.v1.BatchSendRequest\032\033.weaviate.v1.B" + + "atchSendReply\"\000\022S\n\013BatchStream\022\037.weaviat" + + "e.v1.BatchStreamRequest\032\037.weaviate.v1.Ba" + + "tchStreamMessage\"\0000\001B>\n-io.weaviate.clie" + + "nt6.v1.internal.grpc.protocolB\rWeaviateP" + + "rotob\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.getDescriptor(), + }); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoAggregate.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoAggregate.java similarity index 75% rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoAggregate.java rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoAggregate.java index 04f3b74e2..49aad4465 100644 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoAggregate.java +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoAggregate.java @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! // source: v1/aggregate.proto -package io.weaviate.client.grpc.protocol.v1; +package io.weaviate.client6.v1.internal.grpc.protocol; public final class WeaviateProtoAggregate { private WeaviateProtoAggregate() {} @@ -71,12 +71,12 @@ public interface AggregateRequestOrBuilder extends /** * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21; */ - java.util.List + java.util.List getAggregationsList(); /** * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index); /** * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21; */ @@ -84,12 +84,12 @@ public interface AggregateRequestOrBuilder extends /** * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21; */ - java.util.List + java.util.List getAggregationsOrBuilderList(); /** * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder( int index); /** @@ -120,11 +120,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31; * @return The groupBy. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy(); /** * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder(); /** * optional uint32 limit = 32; @@ -154,7 +154,7 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr * optional .weaviate.v1.Filters filters = 40; * @return The filters. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(); /** *
      * matches/searches for objects
@@ -162,7 +162,7 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      *
      * optional .weaviate.v1.Filters filters = 40;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder();
 
     /**
      * .weaviate.v1.Hybrid hybrid = 41;
@@ -173,11 +173,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.Hybrid hybrid = 41;
      * @return The hybrid.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybrid();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybrid();
     /**
      * .weaviate.v1.Hybrid hybrid = 41;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder();
 
     /**
      * .weaviate.v1.NearVector near_vector = 42;
@@ -188,11 +188,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearVector near_vector = 42;
      * @return The nearVector.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector();
     /**
      * .weaviate.v1.NearVector near_vector = 42;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder();
 
     /**
      * .weaviate.v1.NearObject near_object = 43;
@@ -203,11 +203,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearObject near_object = 43;
      * @return The nearObject.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject();
     /**
      * .weaviate.v1.NearObject near_object = 43;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder();
 
     /**
      * .weaviate.v1.NearTextSearch near_text = 44;
@@ -218,11 +218,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearTextSearch near_text = 44;
      * @return The nearText.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText();
     /**
      * .weaviate.v1.NearTextSearch near_text = 44;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder();
 
     /**
      * .weaviate.v1.NearImageSearch near_image = 45;
@@ -233,11 +233,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearImageSearch near_image = 45;
      * @return The nearImage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage();
     /**
      * .weaviate.v1.NearImageSearch near_image = 45;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder();
 
     /**
      * .weaviate.v1.NearAudioSearch near_audio = 46;
@@ -248,11 +248,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearAudioSearch near_audio = 46;
      * @return The nearAudio.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio();
     /**
      * .weaviate.v1.NearAudioSearch near_audio = 46;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder();
 
     /**
      * .weaviate.v1.NearVideoSearch near_video = 47;
@@ -263,11 +263,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearVideoSearch near_video = 47;
      * @return The nearVideo.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo();
     /**
      * .weaviate.v1.NearVideoSearch near_video = 47;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder();
 
     /**
      * .weaviate.v1.NearDepthSearch near_depth = 48;
@@ -278,11 +278,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearDepthSearch near_depth = 48;
      * @return The nearDepth.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth();
     /**
      * .weaviate.v1.NearDepthSearch near_depth = 48;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder();
 
     /**
      * .weaviate.v1.NearThermalSearch near_thermal = 49;
@@ -293,11 +293,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearThermalSearch near_thermal = 49;
      * @return The nearThermal.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal();
     /**
      * .weaviate.v1.NearThermalSearch near_thermal = 49;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder();
 
     /**
      * .weaviate.v1.NearIMUSearch near_imu = 50;
@@ -308,13 +308,13 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggr
      * .weaviate.v1.NearIMUSearch near_imu = 50;
      * @return The nearImu.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu();
     /**
      * .weaviate.v1.NearIMUSearch near_imu = 50;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.SearchCase getSearchCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.SearchCase getSearchCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.AggregateRequest}
@@ -343,15 +343,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Builder.class);
     }
 
     public interface AggregationOrBuilder extends
@@ -379,11 +379,11 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
        * @return The int.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder();
 
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
@@ -394,11 +394,11 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
        * @return The number.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder();
 
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
@@ -409,11 +409,11 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
        * @return The text.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder();
 
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
@@ -424,11 +424,11 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
        * @return The boolean.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder();
 
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
@@ -439,11 +439,11 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
        * @return The date.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder();
 
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
@@ -454,13 +454,13 @@ public interface AggregationOrBuilder extends
        * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
        * @return The reference.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference();
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder();
 
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.AggregationCase getAggregationCase();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.AggregationCase getAggregationCase();
     }
     /**
      * Protobuf type {@code weaviate.v1.AggregateRequest.Aggregation}
@@ -487,15 +487,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder.class);
       }
 
       public interface IntegerOrBuilder extends
@@ -574,15 +574,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder.class);
         }
 
         public static final int COUNT_FIELD_NUMBER = 1;
@@ -762,10 +762,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) obj;
 
           if (getCount()
               != other.getCount()) return false;
@@ -823,44 +823,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -868,26 +868,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -900,7 +900,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -921,21 +921,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Integer)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.newBuilder()
           private Builder() {
 
           }
@@ -963,17 +963,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Integer_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -981,14 +981,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.count_ = count_;
@@ -1050,16 +1050,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance()) return this;
             if (other.getCount() != false) {
               setCount(other.getCount());
             }
@@ -1439,12 +1439,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Integer)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -1480,7 +1480,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -1562,15 +1562,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder.class);
         }
 
         public static final int COUNT_FIELD_NUMBER = 1;
@@ -1750,10 +1750,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) obj;
 
           if (getCount()
               != other.getCount()) return false;
@@ -1811,44 +1811,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -1856,26 +1856,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -1888,7 +1888,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -1909,21 +1909,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Number)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.newBuilder()
           private Builder() {
 
           }
@@ -1951,17 +1951,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Number_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -1969,14 +1969,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.count_ = count_;
@@ -2038,16 +2038,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance()) return this;
             if (other.getCount() != false) {
               setCount(other.getCount());
             }
@@ -2427,12 +2427,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Number)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -2468,7 +2468,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -2531,15 +2531,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder.class);
         }
 
         private int bitField0_;
@@ -2656,10 +2656,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) obj;
 
           if (getCount()
               != other.getCount()) return false;
@@ -2701,44 +2701,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -2746,26 +2746,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -2778,7 +2778,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -2799,21 +2799,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Text)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.newBuilder()
           private Builder() {
 
           }
@@ -2837,17 +2837,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Text_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -2855,14 +2855,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.count_ = count_;
@@ -2915,16 +2915,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance()) return this;
             if (other.getCount() != false) {
               setCount(other.getCount());
             }
@@ -3152,12 +3152,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Text)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -3193,7 +3193,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -3263,15 +3263,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder.class);
         }
 
         public static final int COUNT_FIELD_NUMBER = 1;
@@ -3415,10 +3415,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) obj;
 
           if (getCount()
               != other.getCount()) return false;
@@ -3466,44 +3466,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -3511,26 +3511,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -3543,7 +3543,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -3564,21 +3564,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Boolean)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.newBuilder()
           private Builder() {
 
           }
@@ -3604,17 +3604,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Boolean_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -3622,14 +3622,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.count_ = count_;
@@ -3685,16 +3685,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance()) return this;
             if (other.getCount() != false) {
               setCount(other.getCount());
             }
@@ -3994,12 +3994,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Boolean)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -4035,7 +4035,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -4105,15 +4105,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder.class);
         }
 
         public static final int COUNT_FIELD_NUMBER = 1;
@@ -4257,10 +4257,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) obj;
 
           if (getCount()
               != other.getCount()) return false;
@@ -4308,44 +4308,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -4353,26 +4353,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -4385,7 +4385,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -4406,21 +4406,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Date)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.newBuilder()
           private Builder() {
 
           }
@@ -4446,17 +4446,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Date_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -4464,14 +4464,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.count_ = count_;
@@ -4527,16 +4527,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance()) return this;
             if (other.getCount() != false) {
               setCount(other.getCount());
             }
@@ -4836,12 +4836,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Date)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -4877,7 +4877,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -4923,15 +4923,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder.class);
         }
 
         public static final int TYPE_FIELD_NUMBER = 1;
@@ -5003,10 +5003,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) obj;
 
           if (getType()
               != other.getType()) return false;
@@ -5034,44 +5034,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -5079,26 +5079,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -5111,7 +5111,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -5132,21 +5132,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation.Reference)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.newBuilder()
           private Builder() {
 
           }
@@ -5168,17 +5168,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_Reference_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -5186,14 +5186,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.type_ = type_;
@@ -5237,16 +5237,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance()) return this;
             if (other.getType() != false) {
               setType(other.getType());
             }
@@ -5386,12 +5386,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation.Reference)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -5427,7 +5427,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -5536,21 +5536,21 @@ public boolean hasInt() {
        * @return The int.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt() {
         if (aggregationCase_ == 2) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder() {
         if (aggregationCase_ == 2) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
       }
 
       public static final int NUMBER_FIELD_NUMBER = 3;
@@ -5567,21 +5567,21 @@ public boolean hasNumber() {
        * @return The number.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber() {
         if (aggregationCase_ == 3) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder() {
         if (aggregationCase_ == 3) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
       }
 
       public static final int TEXT_FIELD_NUMBER = 4;
@@ -5598,21 +5598,21 @@ public boolean hasText() {
        * @return The text.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText() {
         if (aggregationCase_ == 4) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder() {
         if (aggregationCase_ == 4) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
       }
 
       public static final int BOOLEAN_FIELD_NUMBER = 5;
@@ -5629,21 +5629,21 @@ public boolean hasBoolean() {
        * @return The boolean.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean() {
         if (aggregationCase_ == 5) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
         if (aggregationCase_ == 5) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
       }
 
       public static final int DATE_FIELD_NUMBER = 6;
@@ -5660,21 +5660,21 @@ public boolean hasDate() {
        * @return The date.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate() {
         if (aggregationCase_ == 6) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder() {
         if (aggregationCase_ == 6) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
       }
 
       public static final int REFERENCE_FIELD_NUMBER = 7;
@@ -5691,21 +5691,21 @@ public boolean hasReference() {
        * @return The reference.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference() {
         if (aggregationCase_ == 7) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
       }
       /**
        * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
         if (aggregationCase_ == 7) {
-           return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
+           return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
         }
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
       }
 
       private byte memoizedIsInitialized = -1;
@@ -5726,22 +5726,22 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
           com.google.protobuf.GeneratedMessageV3.writeString(output, 1, property_);
         }
         if (aggregationCase_ == 2) {
-          output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_);
+          output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_);
         }
         if (aggregationCase_ == 3) {
-          output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_);
+          output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_);
         }
         if (aggregationCase_ == 4) {
-          output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_);
+          output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_);
         }
         if (aggregationCase_ == 5) {
-          output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_);
+          output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_);
         }
         if (aggregationCase_ == 6) {
-          output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_);
+          output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_);
         }
         if (aggregationCase_ == 7) {
-          output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_);
+          output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_);
         }
         getUnknownFields().writeTo(output);
       }
@@ -5757,27 +5757,27 @@ public int getSerializedSize() {
         }
         if (aggregationCase_ == 2) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_);
+            .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_);
         }
         if (aggregationCase_ == 3) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_);
+            .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_);
         }
         if (aggregationCase_ == 4) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_);
+            .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_);
         }
         if (aggregationCase_ == 5) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_);
+            .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_);
         }
         if (aggregationCase_ == 6) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_);
+            .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_);
         }
         if (aggregationCase_ == 7) {
           size += com.google.protobuf.CodedOutputStream
-            .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_);
+            .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_);
         }
         size += getUnknownFields().getSerializedSize();
         memoizedSize = size;
@@ -5789,10 +5789,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation) obj;
 
         if (!getProperty()
             .equals(other.getProperty())) return false;
@@ -5871,44 +5871,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -5916,26 +5916,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -5948,7 +5948,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -5969,21 +5969,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.Aggregation)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.newBuilder()
         private Builder() {
 
         }
@@ -6024,17 +6024,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_Aggregation_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -6042,22 +6042,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           buildPartialOneofs(result);
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.property_ = property_;
           }
         }
 
-        private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation result) {
+        private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation result) {
           result.aggregationCase_ = aggregationCase_;
           result.aggregation_ = this.aggregation_;
           if (aggregationCase_ == 2 &&
@@ -6120,16 +6120,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance()) return this;
           if (!other.getProperty().isEmpty()) {
             property_ = other.property_;
             bitField0_ |= 0x00000001;
@@ -6342,7 +6342,7 @@ public Builder setPropertyBytes(
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder> intBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder> intBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          * @return Whether the int field is set.
@@ -6356,23 +6356,23 @@ public boolean hasInt() {
          * @return The int.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer getInt() {
           if (intBuilder_ == null) {
             if (aggregationCase_ == 2) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
           } else {
             if (aggregationCase_ == 2) {
               return intBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
-        public Builder setInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer value) {
+        public Builder setInt(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer value) {
           if (intBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -6389,7 +6389,7 @@ public Builder setInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
         public Builder setInt(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder builderForValue) {
           if (intBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -6402,11 +6402,11 @@ public Builder setInt(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
-        public Builder mergeInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer value) {
+        public Builder mergeInt(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer value) {
           if (intBuilder_ == null) {
             if (aggregationCase_ == 2 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -6444,36 +6444,36 @@ public Builder clearInt() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder getIntBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder getIntBuilder() {
           return getIntFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder getIntOrBuilder() {
           if ((aggregationCase_ == 2) && (intBuilder_ != null)) {
             return intBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 2) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Integer int = 2;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder> 
             getIntFieldBuilder() {
           if (intBuilder_ == null) {
             if (!(aggregationCase_ == 2)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.getDefaultInstance();
             }
             intBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.IntegerOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Integer) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -6484,7 +6484,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder> numberBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder> numberBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          * @return Whether the number field is set.
@@ -6498,23 +6498,23 @@ public boolean hasNumber() {
          * @return The number.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number getNumber() {
           if (numberBuilder_ == null) {
             if (aggregationCase_ == 3) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
           } else {
             if (aggregationCase_ == 3) {
               return numberBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
-        public Builder setNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number value) {
+        public Builder setNumber(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number value) {
           if (numberBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -6531,7 +6531,7 @@ public Builder setNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggreg
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
         public Builder setNumber(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder builderForValue) {
           if (numberBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -6544,11 +6544,11 @@ public Builder setNumber(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
-        public Builder mergeNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number value) {
+        public Builder mergeNumber(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number value) {
           if (numberBuilder_ == null) {
             if (aggregationCase_ == 3 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -6586,36 +6586,36 @@ public Builder clearNumber() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder getNumberBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder getNumberBuilder() {
           return getNumberFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder getNumberOrBuilder() {
           if ((aggregationCase_ == 3) && (numberBuilder_ != null)) {
             return numberBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 3) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Number number = 3;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder> 
             getNumberFieldBuilder() {
           if (numberBuilder_ == null) {
             if (!(aggregationCase_ == 3)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.getDefaultInstance();
             }
             numberBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.NumberOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Number) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -6626,7 +6626,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder> textBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder> textBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          * @return Whether the text field is set.
@@ -6640,23 +6640,23 @@ public boolean hasText() {
          * @return The text.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text getText() {
           if (textBuilder_ == null) {
             if (aggregationCase_ == 4) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
           } else {
             if (aggregationCase_ == 4) {
               return textBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
-        public Builder setText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text value) {
+        public Builder setText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text value) {
           if (textBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -6673,7 +6673,7 @@ public Builder setText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregat
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
         public Builder setText(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder builderForValue) {
           if (textBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -6686,11 +6686,11 @@ public Builder setText(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
-        public Builder mergeText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text value) {
+        public Builder mergeText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text value) {
           if (textBuilder_ == null) {
             if (aggregationCase_ == 4 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -6728,36 +6728,36 @@ public Builder clearText() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder getTextBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder getTextBuilder() {
           return getTextFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder getTextOrBuilder() {
           if ((aggregationCase_ == 4) && (textBuilder_ != null)) {
             return textBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 4) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Text text = 4;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder> 
             getTextFieldBuilder() {
           if (textBuilder_ == null) {
             if (!(aggregationCase_ == 4)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.getDefaultInstance();
             }
             textBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.TextOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Text) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -6768,7 +6768,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder> booleanBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder> booleanBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          * @return Whether the boolean field is set.
@@ -6782,23 +6782,23 @@ public boolean hasBoolean() {
          * @return The boolean.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean getBoolean() {
           if (booleanBuilder_ == null) {
             if (aggregationCase_ == 5) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
           } else {
             if (aggregationCase_ == 5) {
               return booleanBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
-        public Builder setBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean value) {
+        public Builder setBoolean(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean value) {
           if (booleanBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -6815,7 +6815,7 @@ public Builder setBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggre
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
         public Builder setBoolean(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder builderForValue) {
           if (booleanBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -6828,11 +6828,11 @@ public Builder setBoolean(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
-        public Builder mergeBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean value) {
+        public Builder mergeBoolean(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean value) {
           if (booleanBuilder_ == null) {
             if (aggregationCase_ == 5 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -6870,36 +6870,36 @@ public Builder clearBoolean() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder getBooleanBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder getBooleanBuilder() {
           return getBooleanFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
           if ((aggregationCase_ == 5) && (booleanBuilder_ != null)) {
             return booleanBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 5) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Boolean boolean = 5;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder> 
             getBooleanFieldBuilder() {
           if (booleanBuilder_ == null) {
             if (!(aggregationCase_ == 5)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.getDefaultInstance();
             }
             booleanBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.BooleanOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Boolean) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -6910,7 +6910,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder> dateBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder> dateBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          * @return Whether the date field is set.
@@ -6924,23 +6924,23 @@ public boolean hasDate() {
          * @return The date.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date getDate() {
           if (dateBuilder_ == null) {
             if (aggregationCase_ == 6) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
           } else {
             if (aggregationCase_ == 6) {
               return dateBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
-        public Builder setDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date value) {
+        public Builder setDate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date value) {
           if (dateBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -6957,7 +6957,7 @@ public Builder setDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregat
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
         public Builder setDate(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder builderForValue) {
           if (dateBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -6970,11 +6970,11 @@ public Builder setDate(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
-        public Builder mergeDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date value) {
+        public Builder mergeDate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date value) {
           if (dateBuilder_ == null) {
             if (aggregationCase_ == 6 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -7012,36 +7012,36 @@ public Builder clearDate() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder getDateBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder getDateBuilder() {
           return getDateFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder getDateOrBuilder() {
           if ((aggregationCase_ == 6) && (dateBuilder_ != null)) {
             return dateBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 6) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Date date = 6;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder> 
             getDateFieldBuilder() {
           if (dateBuilder_ == null) {
             if (!(aggregationCase_ == 6)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.getDefaultInstance();
             }
             dateBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.DateOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Date) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -7052,7 +7052,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder> referenceBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder> referenceBuilder_;
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          * @return Whether the reference field is set.
@@ -7066,23 +7066,23 @@ public boolean hasReference() {
          * @return The reference.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference getReference() {
           if (referenceBuilder_ == null) {
             if (aggregationCase_ == 7) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
           } else {
             if (aggregationCase_ == 7) {
               return referenceBuilder_.getMessage();
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
-        public Builder setReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference value) {
+        public Builder setReference(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference value) {
           if (referenceBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -7099,7 +7099,7 @@ public Builder setReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAgg
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
         public Builder setReference(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder builderForValue) {
           if (referenceBuilder_ == null) {
             aggregation_ = builderForValue.build();
             onChanged();
@@ -7112,11 +7112,11 @@ public Builder setReference(
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
-        public Builder mergeReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference value) {
+        public Builder mergeReference(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference value) {
           if (referenceBuilder_ == null) {
             if (aggregationCase_ == 7 &&
-                aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance()) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_)
+                aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance()) {
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_)
                   .mergeFrom(value).buildPartial();
             } else {
               aggregation_ = value;
@@ -7154,36 +7154,36 @@ public Builder clearReference() {
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder getReferenceBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder getReferenceBuilder() {
           return getReferenceFieldBuilder().getBuilder();
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
           if ((aggregationCase_ == 7) && (referenceBuilder_ != null)) {
             return referenceBuilder_.getMessageOrBuilder();
           } else {
             if (aggregationCase_ == 7) {
-              return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
+              return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_;
             }
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
           }
         }
         /**
          * .weaviate.v1.AggregateRequest.Aggregation.Reference reference = 7;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder> 
             getReferenceFieldBuilder() {
           if (referenceBuilder_ == null) {
             if (!(aggregationCase_ == 7)) {
-              aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
+              aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.getDefaultInstance();
             }
             referenceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder>(
-                    (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_,
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.ReferenceOrBuilder>(
+                    (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Reference) aggregation_,
                     getParentForChildren(),
                     isClean());
             aggregation_ = null;
@@ -7209,12 +7209,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.Aggregation)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -7250,7 +7250,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -7310,15 +7310,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder.class);
       }
 
       public static final int COLLECTION_FIELD_NUMBER = 1;
@@ -7444,10 +7444,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy) obj;
 
         if (!getCollection()
             .equals(other.getCollection())) return false;
@@ -7473,44 +7473,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -7518,26 +7518,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -7550,7 +7550,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -7571,21 +7571,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest.GroupBy)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.newBuilder()
         private Builder() {
 
         }
@@ -7607,17 +7607,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_GroupBy_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -7625,14 +7625,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.collection_ = collection_;
@@ -7676,16 +7676,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance()) return this;
           if (!other.getCollection().isEmpty()) {
             collection_ = other.collection_;
             bitField0_ |= 0x00000001;
@@ -7909,12 +7909,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest.GroupBy)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -7950,7 +7950,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -8126,19 +8126,19 @@ public boolean getObjectsCount() {
 
     public static final int AGGREGATIONS_FIELD_NUMBER = 21;
     @SuppressWarnings("serial")
-    private java.util.List aggregations_;
+    private java.util.List aggregations_;
     /**
      * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
      */
     @java.lang.Override
-    public java.util.List getAggregationsList() {
+    public java.util.List getAggregationsList() {
       return aggregations_;
     }
     /**
      * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getAggregationsOrBuilderList() {
       return aggregations_;
     }
@@ -8153,14 +8153,14 @@ public int getAggregationsCount() {
      * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index) {
       return aggregations_.get(index);
     }
     /**
      * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder(
         int index) {
       return aggregations_.get(index);
     }
@@ -8193,7 +8193,7 @@ public int getObjectLimit() {
     }
 
     public static final int GROUP_BY_FIELD_NUMBER = 31;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy groupBy_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy groupBy_;
     /**
      * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
      * @return Whether the groupBy field is set.
@@ -8207,15 +8207,15 @@ public boolean hasGroupBy() {
      * @return The groupBy.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy() {
-      return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy() {
+      return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
     }
     /**
      * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder() {
-      return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder() {
+      return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
     }
 
     public static final int LIMIT_FIELD_NUMBER = 32;
@@ -8238,7 +8238,7 @@ public int getLimit() {
     }
 
     public static final int FILTERS_FIELD_NUMBER = 40;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_;
     /**
      * 
      * matches/searches for objects
@@ -8260,8 +8260,8 @@ public boolean hasFilters() {
      * @return The filters.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() {
-      return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() {
+      return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
     }
     /**
      * 
@@ -8271,8 +8271,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(
      * optional .weaviate.v1.Filters filters = 40;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() {
-      return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() {
+      return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
     }
 
     public static final int HYBRID_FIELD_NUMBER = 41;
@@ -8289,21 +8289,21 @@ public boolean hasHybrid() {
      * @return The hybrid.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybrid() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybrid() {
       if (searchCase_ == 41) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
     }
     /**
      * .weaviate.v1.Hybrid hybrid = 41;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder() {
       if (searchCase_ == 41) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
     }
 
     public static final int NEAR_VECTOR_FIELD_NUMBER = 42;
@@ -8320,21 +8320,21 @@ public boolean hasNearVector() {
      * @return The nearVector.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() {
       if (searchCase_ == 42) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearVector near_vector = 42;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
       if (searchCase_ == 42) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
     }
 
     public static final int NEAR_OBJECT_FIELD_NUMBER = 43;
@@ -8351,21 +8351,21 @@ public boolean hasNearObject() {
      * @return The nearObject.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject() {
       if (searchCase_ == 43) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearObject near_object = 43;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() {
       if (searchCase_ == 43) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
     }
 
     public static final int NEAR_TEXT_FIELD_NUMBER = 44;
@@ -8382,21 +8382,21 @@ public boolean hasNearText() {
      * @return The nearText.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
       if (searchCase_ == 44) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearTextSearch near_text = 44;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
       if (searchCase_ == 44) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
     }
 
     public static final int NEAR_IMAGE_FIELD_NUMBER = 45;
@@ -8413,21 +8413,21 @@ public boolean hasNearImage() {
      * @return The nearImage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage() {
       if (searchCase_ == 45) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearImageSearch near_image = 45;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() {
       if (searchCase_ == 45) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
     }
 
     public static final int NEAR_AUDIO_FIELD_NUMBER = 46;
@@ -8444,21 +8444,21 @@ public boolean hasNearAudio() {
      * @return The nearAudio.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() {
       if (searchCase_ == 46) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearAudioSearch near_audio = 46;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() {
       if (searchCase_ == 46) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
     }
 
     public static final int NEAR_VIDEO_FIELD_NUMBER = 47;
@@ -8475,21 +8475,21 @@ public boolean hasNearVideo() {
      * @return The nearVideo.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() {
       if (searchCase_ == 47) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearVideoSearch near_video = 47;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() {
       if (searchCase_ == 47) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
     }
 
     public static final int NEAR_DEPTH_FIELD_NUMBER = 48;
@@ -8506,21 +8506,21 @@ public boolean hasNearDepth() {
      * @return The nearDepth.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() {
       if (searchCase_ == 48) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearDepthSearch near_depth = 48;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() {
       if (searchCase_ == 48) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
     }
 
     public static final int NEAR_THERMAL_FIELD_NUMBER = 49;
@@ -8537,21 +8537,21 @@ public boolean hasNearThermal() {
      * @return The nearThermal.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() {
       if (searchCase_ == 49) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearThermalSearch near_thermal = 49;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() {
       if (searchCase_ == 49) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
     }
 
     public static final int NEAR_IMU_FIELD_NUMBER = 50;
@@ -8568,21 +8568,21 @@ public boolean hasNearImu() {
      * @return The nearImu.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() {
       if (searchCase_ == 50) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NearIMUSearch near_imu = 50;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() {
       if (searchCase_ == 50) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
     }
 
     private byte memoizedIsInitialized = -1;
@@ -8624,34 +8624,34 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
         output.writeMessage(40, getFilters());
       }
       if (searchCase_ == 41) {
-        output.writeMessage(41, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_);
+        output.writeMessage(41, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_);
       }
       if (searchCase_ == 42) {
-        output.writeMessage(42, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_);
+        output.writeMessage(42, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_);
       }
       if (searchCase_ == 43) {
-        output.writeMessage(43, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_);
+        output.writeMessage(43, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_);
       }
       if (searchCase_ == 44) {
-        output.writeMessage(44, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_);
+        output.writeMessage(44, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_);
       }
       if (searchCase_ == 45) {
-        output.writeMessage(45, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_);
+        output.writeMessage(45, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_);
       }
       if (searchCase_ == 46) {
-        output.writeMessage(46, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_);
+        output.writeMessage(46, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_);
       }
       if (searchCase_ == 47) {
-        output.writeMessage(47, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_);
+        output.writeMessage(47, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_);
       }
       if (searchCase_ == 48) {
-        output.writeMessage(48, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_);
+        output.writeMessage(48, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_);
       }
       if (searchCase_ == 49) {
-        output.writeMessage(49, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_);
+        output.writeMessage(49, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_);
       }
       if (searchCase_ == 50) {
-        output.writeMessage(50, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_);
+        output.writeMessage(50, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -8694,43 +8694,43 @@ public int getSerializedSize() {
       }
       if (searchCase_ == 41) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(41, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_);
+          .computeMessageSize(41, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_);
       }
       if (searchCase_ == 42) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(42, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_);
+          .computeMessageSize(42, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_);
       }
       if (searchCase_ == 43) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(43, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_);
+          .computeMessageSize(43, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_);
       }
       if (searchCase_ == 44) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(44, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_);
+          .computeMessageSize(44, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_);
       }
       if (searchCase_ == 45) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(45, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_);
+          .computeMessageSize(45, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_);
       }
       if (searchCase_ == 46) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(46, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_);
+          .computeMessageSize(46, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_);
       }
       if (searchCase_ == 47) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(47, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_);
+          .computeMessageSize(47, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_);
       }
       if (searchCase_ == 48) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(48, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_);
+          .computeMessageSize(48, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_);
       }
       if (searchCase_ == 49) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(49, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_);
+          .computeMessageSize(49, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_);
       }
       if (searchCase_ == 50) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(50, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_);
+          .computeMessageSize(50, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSize = size;
@@ -8742,10 +8742,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest) obj;
 
       if (!getCollection()
           .equals(other.getCollection())) return false;
@@ -8907,44 +8907,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8952,26 +8952,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8984,7 +8984,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -9005,21 +9005,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateRequest)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequestOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequestOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -9101,17 +9101,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateRequest_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -9119,8 +9119,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
@@ -9128,7 +9128,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest result) {
         if (aggregationsBuilder_ == null) {
           if (((bitField0_ & 0x00000008) != 0)) {
             aggregations_ = java.util.Collections.unmodifiableList(aggregations_);
@@ -9140,7 +9140,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.collection_ = collection_;
@@ -9175,7 +9175,7 @@ private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggr
         result.bitField0_ |= to_bitField0_;
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest result) {
         result.searchCase_ = searchCase_;
         result.search_ = this.search_;
         if (searchCase_ == 41 &&
@@ -9254,16 +9254,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.getDefaultInstance()) return this;
         if (!other.getCollection().isEmpty()) {
           collection_ = other.collection_;
           bitField0_ |= 0x00000001;
@@ -9402,9 +9402,9 @@ public Builder mergeFrom(
                 break;
               } // case 160
               case 170: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.parser(),
                         extensionRegistry);
                 if (aggregationsBuilder_ == null) {
                   ensureAggregationsIsMutable();
@@ -9768,22 +9768,22 @@ public Builder clearObjectsCount() {
         return this;
       }
 
-      private java.util.List aggregations_ =
+      private java.util.List aggregations_ =
         java.util.Collections.emptyList();
       private void ensureAggregationsIsMutable() {
         if (!((bitField0_ & 0x00000008) != 0)) {
-          aggregations_ = new java.util.ArrayList(aggregations_);
+          aggregations_ = new java.util.ArrayList(aggregations_);
           bitField0_ |= 0x00000008;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder> aggregationsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder> aggregationsBuilder_;
 
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public java.util.List getAggregationsList() {
+      public java.util.List getAggregationsList() {
         if (aggregationsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(aggregations_);
         } else {
@@ -9803,7 +9803,7 @@ public int getAggregationsCount() {
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation getAggregations(int index) {
         if (aggregationsBuilder_ == null) {
           return aggregations_.get(index);
         } else {
@@ -9814,7 +9814,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder setAggregations(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
         if (aggregationsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9831,7 +9831,7 @@ public Builder setAggregations(
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder setAggregations(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
         if (aggregationsBuilder_ == null) {
           ensureAggregationsIsMutable();
           aggregations_.set(index, builderForValue.build());
@@ -9844,7 +9844,7 @@ public Builder setAggregations(
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public Builder addAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
+      public Builder addAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
         if (aggregationsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9861,7 +9861,7 @@ public Builder addAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProto
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder addAggregations(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation value) {
         if (aggregationsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9878,7 +9878,7 @@ public Builder addAggregations(
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder addAggregations(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
         if (aggregationsBuilder_ == null) {
           ensureAggregationsIsMutable();
           aggregations_.add(builderForValue.build());
@@ -9892,7 +9892,7 @@ public Builder addAggregations(
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder addAggregations(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder builderForValue) {
         if (aggregationsBuilder_ == null) {
           ensureAggregationsIsMutable();
           aggregations_.add(index, builderForValue.build());
@@ -9906,7 +9906,7 @@ public Builder addAggregations(
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
       public Builder addAllAggregations(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (aggregationsBuilder_ == null) {
           ensureAggregationsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -9946,14 +9946,14 @@ public Builder removeAggregations(int index) {
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder getAggregationsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder getAggregationsBuilder(
           int index) {
         return getAggregationsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder getAggregationsOrBuilder(
           int index) {
         if (aggregationsBuilder_ == null) {
           return aggregations_.get(index);  } else {
@@ -9963,7 +9963,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public java.util.List 
+      public java.util.List 
            getAggregationsOrBuilderList() {
         if (aggregationsBuilder_ != null) {
           return aggregationsBuilder_.getMessageOrBuilderList();
@@ -9974,31 +9974,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder addAggregationsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder addAggregationsBuilder() {
         return getAggregationsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder addAggregationsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder addAggregationsBuilder(
           int index) {
         return getAggregationsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.AggregateRequest.Aggregation aggregations = 21;
        */
-      public java.util.List 
+      public java.util.List 
            getAggregationsBuilderList() {
         return getAggregationsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder> 
           getAggregationsFieldBuilder() {
         if (aggregationsBuilder_ == null) {
           aggregationsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.AggregationOrBuilder>(
                   aggregations_,
                   ((bitField0_ & 0x00000008) != 0),
                   getParentForChildren(),
@@ -10064,9 +10064,9 @@ public Builder clearObjectLimit() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy groupBy_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy groupBy_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder> groupByBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder> groupByBuilder_;
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        * @return Whether the groupBy field is set.
@@ -10078,9 +10078,9 @@ public boolean hasGroupBy() {
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        * @return The groupBy.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy getGroupBy() {
         if (groupByBuilder_ == null) {
-          return groupBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
+          return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
         } else {
           return groupByBuilder_.getMessage();
         }
@@ -10088,7 +10088,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
-      public Builder setGroupBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy value) {
+      public Builder setGroupBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy value) {
         if (groupByBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10105,7 +10105,7 @@ public Builder setGroupBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggre
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
       public Builder setGroupBy(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder builderForValue) {
         if (groupByBuilder_ == null) {
           groupBy_ = builderForValue.build();
         } else {
@@ -10118,11 +10118,11 @@ public Builder setGroupBy(
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
-      public Builder mergeGroupBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy value) {
+      public Builder mergeGroupBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy value) {
         if (groupByBuilder_ == null) {
           if (((bitField0_ & 0x00000020) != 0) &&
             groupBy_ != null &&
-            groupBy_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance()) {
+            groupBy_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance()) {
             getGroupByBuilder().mergeFrom(value);
           } else {
             groupBy_ = value;
@@ -10152,7 +10152,7 @@ public Builder clearGroupBy() {
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder getGroupByBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder getGroupByBuilder() {
         bitField0_ |= 0x00000020;
         onChanged();
         return getGroupByFieldBuilder().getBuilder();
@@ -10160,23 +10160,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReque
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder getGroupByOrBuilder() {
         if (groupByBuilder_ != null) {
           return groupByBuilder_.getMessageOrBuilder();
         } else {
           return groupBy_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.getDefaultInstance() : groupBy_;
         }
       }
       /**
        * optional .weaviate.v1.AggregateRequest.GroupBy group_by = 31;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder> 
           getGroupByFieldBuilder() {
         if (groupByBuilder_ == null) {
           groupByBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest.GroupByOrBuilder>(
                   getGroupBy(),
                   getParentForChildren(),
                   isClean());
@@ -10225,9 +10225,9 @@ public Builder clearLimit() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_;
       /**
        * 
        * matches/searches for objects
@@ -10247,9 +10247,9 @@ public boolean hasFilters() {
        * optional .weaviate.v1.Filters filters = 40;
        * @return The filters.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() {
         if (filtersBuilder_ == null) {
-          return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
+          return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
         } else {
           return filtersBuilder_.getMessage();
         }
@@ -10261,7 +10261,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(
        *
        * optional .weaviate.v1.Filters filters = 40;
        */
-      public Builder setFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) {
+      public Builder setFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) {
         if (filtersBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10282,7 +10282,7 @@ public Builder setFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
        * optional .weaviate.v1.Filters filters = 40;
        */
       public Builder setFilters(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) {
         if (filtersBuilder_ == null) {
           filters_ = builderForValue.build();
         } else {
@@ -10299,11 +10299,11 @@ public Builder setFilters(
        *
        * optional .weaviate.v1.Filters filters = 40;
        */
-      public Builder mergeFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) {
+      public Builder mergeFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) {
         if (filtersBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             filters_ != null &&
-            filters_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance()) {
+            filters_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance()) {
             getFiltersBuilder().mergeFrom(value);
           } else {
             filters_ = value;
@@ -10341,7 +10341,7 @@ public Builder clearFilters() {
        *
        * optional .weaviate.v1.Filters filters = 40;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder getFiltersBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder getFiltersBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getFiltersFieldBuilder().getBuilder();
@@ -10353,12 +10353,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder get
        *
        * optional .weaviate.v1.Filters filters = 40;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() {
         if (filtersBuilder_ != null) {
           return filtersBuilder_.getMessageOrBuilder();
         } else {
           return filters_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_;
         }
       }
       /**
@@ -10369,11 +10369,11 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder ge
        * optional .weaviate.v1.Filters filters = 40;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> 
           getFiltersFieldBuilder() {
         if (filtersBuilder_ == null) {
           filtersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder>(
                   getFilters(),
                   getParentForChildren(),
                   isClean());
@@ -10383,7 +10383,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder ge
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder> hybridBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder> hybridBuilder_;
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        * @return Whether the hybrid field is set.
@@ -10397,23 +10397,23 @@ public boolean hasHybrid() {
        * @return The hybrid.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getHybrid() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybrid() {
         if (hybridBuilder_ == null) {
           if (searchCase_ == 41) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
         } else {
           if (searchCase_ == 41) {
             return hybridBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        */
-      public Builder setHybrid(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid value) {
+      public Builder setHybrid(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid value) {
         if (hybridBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10430,7 +10430,7 @@ public Builder setHybrid(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSe
        * .weaviate.v1.Hybrid hybrid = 41;
        */
       public Builder setHybrid(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder builderForValue) {
         if (hybridBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -10443,11 +10443,11 @@ public Builder setHybrid(
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        */
-      public Builder mergeHybrid(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid value) {
+      public Builder mergeHybrid(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid value) {
         if (hybridBuilder_ == null) {
           if (searchCase_ == 41 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -10485,36 +10485,36 @@ public Builder clearHybrid() {
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder getHybridBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder getHybridBuilder() {
         return getHybridFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridOrBuilder() {
         if ((searchCase_ == 41) && (hybridBuilder_ != null)) {
           return hybridBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 41) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.Hybrid hybrid = 41;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder> 
           getHybridFieldBuilder() {
         if (hybridBuilder_ == null) {
           if (!(searchCase_ == 41)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
           }
           hybridBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -10525,7 +10525,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuild
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_;
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        * @return Whether the nearVector field is set.
@@ -10539,23 +10539,23 @@ public boolean hasNearVector() {
        * @return The nearVector.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() {
         if (nearVectorBuilder_ == null) {
           if (searchCase_ == 42) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
         } else {
           if (searchCase_ == 42) {
             return nearVectorBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        */
-      public Builder setNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) {
+      public Builder setNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) {
         if (nearVectorBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10572,7 +10572,7 @@ public Builder setNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBa
        * .weaviate.v1.NearVector near_vector = 42;
        */
       public Builder setNearVector(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) {
         if (nearVectorBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -10585,11 +10585,11 @@ public Builder setNearVector(
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        */
-      public Builder mergeNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) {
+      public Builder mergeNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) {
         if (nearVectorBuilder_ == null) {
           if (searchCase_ == 42 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -10627,36 +10627,36 @@ public Builder clearNearVector() {
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() {
         return getNearVectorFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
         if ((searchCase_ == 42) && (nearVectorBuilder_ != null)) {
           return nearVectorBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 42) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearVector near_vector = 42;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> 
           getNearVectorFieldBuilder() {
         if (nearVectorBuilder_ == null) {
           if (!(searchCase_ == 42)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
           }
           nearVectorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -10667,7 +10667,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrB
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder> nearObjectBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder> nearObjectBuilder_;
       /**
        * .weaviate.v1.NearObject near_object = 43;
        * @return Whether the nearObject field is set.
@@ -10681,23 +10681,23 @@ public boolean hasNearObject() {
        * @return The nearObject.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getNearObject() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject() {
         if (nearObjectBuilder_ == null) {
           if (searchCase_ == 43) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
         } else {
           if (searchCase_ == 43) {
             return nearObjectBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearObject near_object = 43;
        */
-      public Builder setNearObject(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject value) {
+      public Builder setNearObject(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject value) {
         if (nearObjectBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10714,7 +10714,7 @@ public Builder setNearObject(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBa
        * .weaviate.v1.NearObject near_object = 43;
        */
       public Builder setNearObject(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder builderForValue) {
         if (nearObjectBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -10727,11 +10727,11 @@ public Builder setNearObject(
       /**
        * .weaviate.v1.NearObject near_object = 43;
        */
-      public Builder mergeNearObject(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject value) {
+      public Builder mergeNearObject(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject value) {
         if (nearObjectBuilder_ == null) {
           if (searchCase_ == 43 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -10769,36 +10769,36 @@ public Builder clearNearObject() {
       /**
        * .weaviate.v1.NearObject near_object = 43;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder getNearObjectBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder getNearObjectBuilder() {
         return getNearObjectFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearObject near_object = 43;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() {
         if ((searchCase_ == 43) && (nearObjectBuilder_ != null)) {
           return nearObjectBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 43) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearObject near_object = 43;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder> 
           getNearObjectFieldBuilder() {
         if (nearObjectBuilder_ == null) {
           if (!(searchCase_ == 43)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
           }
           nearObjectBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -10809,7 +10809,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrB
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_;
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        * @return Whether the nearText field is set.
@@ -10823,23 +10823,23 @@ public boolean hasNearText() {
        * @return The nearText.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
         if (nearTextBuilder_ == null) {
           if (searchCase_ == 44) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 44) {
             return nearTextBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
-      public Builder setNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) {
+      public Builder setNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) {
         if (nearTextBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10856,7 +10856,7 @@ public Builder setNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
       public Builder setNearText(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) {
         if (nearTextBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -10869,11 +10869,11 @@ public Builder setNearText(
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
-      public Builder mergeNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) {
+      public Builder mergeNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) {
         if (nearTextBuilder_ == null) {
           if (searchCase_ == 44 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -10911,36 +10911,36 @@ public Builder clearNearText() {
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() {
         return getNearTextFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
         if ((searchCase_ == 44) && (nearTextBuilder_ != null)) {
           return nearTextBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 44) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearTextSearch near_text = 44;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> 
           getNearTextFieldBuilder() {
         if (nearTextBuilder_ == null) {
           if (!(searchCase_ == 44)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
           }
           nearTextBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -10951,7 +10951,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> nearImageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> nearImageBuilder_;
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        * @return Whether the nearImage field is set.
@@ -10965,23 +10965,23 @@ public boolean hasNearImage() {
        * @return The nearImage.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getNearImage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage() {
         if (nearImageBuilder_ == null) {
           if (searchCase_ == 45) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 45) {
             return nearImageBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
-      public Builder setNearImage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch value) {
+      public Builder setNearImage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch value) {
         if (nearImageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10998,7 +10998,7 @@ public Builder setNearImage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBas
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
       public Builder setNearImage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder builderForValue) {
         if (nearImageBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11011,11 +11011,11 @@ public Builder setNearImage(
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
-      public Builder mergeNearImage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch value) {
+      public Builder mergeNearImage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch value) {
         if (nearImageBuilder_ == null) {
           if (searchCase_ == 45 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11053,36 +11053,36 @@ public Builder clearNearImage() {
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder getNearImageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder getNearImageBuilder() {
         return getNearImageFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() {
         if ((searchCase_ == 45) && (nearImageBuilder_ != null)) {
           return nearImageBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 45) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearImageSearch near_image = 45;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> 
           getNearImageFieldBuilder() {
         if (nearImageBuilder_ == null) {
           if (!(searchCase_ == 45)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
           }
           nearImageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11093,7 +11093,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSear
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> nearAudioBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> nearAudioBuilder_;
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        * @return Whether the nearAudio field is set.
@@ -11107,23 +11107,23 @@ public boolean hasNearAudio() {
        * @return The nearAudio.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() {
         if (nearAudioBuilder_ == null) {
           if (searchCase_ == 46) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 46) {
             return nearAudioBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
-      public Builder setNearAudio(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch value) {
+      public Builder setNearAudio(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch value) {
         if (nearAudioBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11140,7 +11140,7 @@ public Builder setNearAudio(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBas
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
       public Builder setNearAudio(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder builderForValue) {
         if (nearAudioBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11153,11 +11153,11 @@ public Builder setNearAudio(
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
-      public Builder mergeNearAudio(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch value) {
+      public Builder mergeNearAudio(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch value) {
         if (nearAudioBuilder_ == null) {
           if (searchCase_ == 46 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11195,36 +11195,36 @@ public Builder clearNearAudio() {
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder getNearAudioBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder getNearAudioBuilder() {
         return getNearAudioFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() {
         if ((searchCase_ == 46) && (nearAudioBuilder_ != null)) {
           return nearAudioBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 46) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearAudioSearch near_audio = 46;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> 
           getNearAudioFieldBuilder() {
         if (nearAudioBuilder_ == null) {
           if (!(searchCase_ == 46)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
           }
           nearAudioBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11235,7 +11235,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSear
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> nearVideoBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> nearVideoBuilder_;
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        * @return Whether the nearVideo field is set.
@@ -11249,23 +11249,23 @@ public boolean hasNearVideo() {
        * @return The nearVideo.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() {
         if (nearVideoBuilder_ == null) {
           if (searchCase_ == 47) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 47) {
             return nearVideoBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
-      public Builder setNearVideo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch value) {
+      public Builder setNearVideo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch value) {
         if (nearVideoBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11282,7 +11282,7 @@ public Builder setNearVideo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBas
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
       public Builder setNearVideo(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder builderForValue) {
         if (nearVideoBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11295,11 +11295,11 @@ public Builder setNearVideo(
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
-      public Builder mergeNearVideo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch value) {
+      public Builder mergeNearVideo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch value) {
         if (nearVideoBuilder_ == null) {
           if (searchCase_ == 47 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11337,36 +11337,36 @@ public Builder clearNearVideo() {
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder getNearVideoBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder getNearVideoBuilder() {
         return getNearVideoFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() {
         if ((searchCase_ == 47) && (nearVideoBuilder_ != null)) {
           return nearVideoBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 47) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearVideoSearch near_video = 47;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> 
           getNearVideoFieldBuilder() {
         if (nearVideoBuilder_ == null) {
           if (!(searchCase_ == 47)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
           }
           nearVideoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11377,7 +11377,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSear
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> nearDepthBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> nearDepthBuilder_;
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        * @return Whether the nearDepth field is set.
@@ -11391,23 +11391,23 @@ public boolean hasNearDepth() {
        * @return The nearDepth.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() {
         if (nearDepthBuilder_ == null) {
           if (searchCase_ == 48) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 48) {
             return nearDepthBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
-      public Builder setNearDepth(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch value) {
+      public Builder setNearDepth(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch value) {
         if (nearDepthBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11424,7 +11424,7 @@ public Builder setNearDepth(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBas
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
       public Builder setNearDepth(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder builderForValue) {
         if (nearDepthBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11437,11 +11437,11 @@ public Builder setNearDepth(
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
-      public Builder mergeNearDepth(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch value) {
+      public Builder mergeNearDepth(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch value) {
         if (nearDepthBuilder_ == null) {
           if (searchCase_ == 48 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11479,36 +11479,36 @@ public Builder clearNearDepth() {
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder getNearDepthBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder getNearDepthBuilder() {
         return getNearDepthFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() {
         if ((searchCase_ == 48) && (nearDepthBuilder_ != null)) {
           return nearDepthBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 48) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearDepthSearch near_depth = 48;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> 
           getNearDepthFieldBuilder() {
         if (nearDepthBuilder_ == null) {
           if (!(searchCase_ == 48)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
           }
           nearDepthBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11519,7 +11519,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSear
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> nearThermalBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> nearThermalBuilder_;
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        * @return Whether the nearThermal field is set.
@@ -11533,23 +11533,23 @@ public boolean hasNearThermal() {
        * @return The nearThermal.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() {
         if (nearThermalBuilder_ == null) {
           if (searchCase_ == 49) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 49) {
             return nearThermalBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
-      public Builder setNearThermal(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch value) {
+      public Builder setNearThermal(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch value) {
         if (nearThermalBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11566,7 +11566,7 @@ public Builder setNearThermal(io.weaviate.client.grpc.protocol.v1.WeaviateProtoB
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
       public Builder setNearThermal(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder builderForValue) {
         if (nearThermalBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11579,11 +11579,11 @@ public Builder setNearThermal(
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
-      public Builder mergeNearThermal(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch value) {
+      public Builder mergeNearThermal(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch value) {
         if (nearThermalBuilder_ == null) {
           if (searchCase_ == 49 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11621,36 +11621,36 @@ public Builder clearNearThermal() {
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder getNearThermalBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder getNearThermalBuilder() {
         return getNearThermalFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() {
         if ((searchCase_ == 49) && (nearThermalBuilder_ != null)) {
           return nearThermalBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 49) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearThermalSearch near_thermal = 49;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> 
           getNearThermalFieldBuilder() {
         if (nearThermalBuilder_ == null) {
           if (!(searchCase_ == 49)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
           }
           nearThermalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11661,7 +11661,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSe
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> nearImuBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> nearImuBuilder_;
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        * @return Whether the nearImu field is set.
@@ -11675,23 +11675,23 @@ public boolean hasNearImu() {
        * @return The nearImu.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() {
         if (nearImuBuilder_ == null) {
           if (searchCase_ == 50) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
         } else {
           if (searchCase_ == 50) {
             return nearImuBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
-      public Builder setNearImu(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch value) {
+      public Builder setNearImu(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch value) {
         if (nearImuBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11708,7 +11708,7 @@ public Builder setNearImu(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
       public Builder setNearImu(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder builderForValue) {
         if (nearImuBuilder_ == null) {
           search_ = builderForValue.build();
           onChanged();
@@ -11721,11 +11721,11 @@ public Builder setNearImu(
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
-      public Builder mergeNearImu(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch value) {
+      public Builder mergeNearImu(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch value) {
         if (nearImuBuilder_ == null) {
           if (searchCase_ == 50 &&
-              search_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_)
+              search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) {
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_)
                 .mergeFrom(value).buildPartial();
           } else {
             search_ = value;
@@ -11763,36 +11763,36 @@ public Builder clearNearImu() {
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder getNearImuBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder getNearImuBuilder() {
         return getNearImuFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() {
         if ((searchCase_ == 50) && (nearImuBuilder_ != null)) {
           return nearImuBuilder_.getMessageOrBuilder();
         } else {
           if (searchCase_ == 50) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NearIMUSearch near_imu = 50;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> 
           getNearImuFieldBuilder() {
         if (nearImuBuilder_ == null) {
           if (!(searchCase_ == 50)) {
-            search_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+            search_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
           }
           nearImuBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) search_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) search_,
                   getParentForChildren(),
                   isClean());
           search_ = null;
@@ -11818,12 +11818,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateRequest)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -11859,7 +11859,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateRequest getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateRequest getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -11884,11 +11884,11 @@ public interface AggregateReplyOrBuilder extends
      * .weaviate.v1.AggregateReply.Single single_result = 2;
      * @return The singleResult.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getSingleResult();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getSingleResult();
     /**
      * .weaviate.v1.AggregateReply.Single single_result = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder();
 
     /**
      * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
@@ -11899,13 +11899,13 @@ public interface AggregateReplyOrBuilder extends
      * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
      * @return The groupedResults.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults();
     /**
      * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.ResultCase getResultCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.ResultCase getResultCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.AggregateReply}
@@ -11931,15 +11931,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Builder.class);
     }
 
     public interface AggregationsOrBuilder extends
@@ -11949,12 +11949,12 @@ public interface AggregationsOrBuilder extends
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
-      java.util.List 
+      java.util.List 
           getAggregationsList();
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index);
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index);
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
@@ -11962,12 +11962,12 @@ public interface AggregationsOrBuilder extends
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
-      java.util.List 
+      java.util.List 
           getAggregationsOrBuilderList();
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
           int index);
     }
     /**
@@ -11995,15 +11995,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder.class);
       }
 
       public interface AggregationOrBuilder extends
@@ -12031,11 +12031,11 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
          * @return The int.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder();
 
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
@@ -12046,11 +12046,11 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
          * @return The number.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder();
 
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
@@ -12061,11 +12061,11 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
          * @return The text.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder();
 
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
@@ -12076,11 +12076,11 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
          * @return The boolean.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder();
 
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
@@ -12091,11 +12091,11 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
          * @return The date.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder();
 
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
@@ -12106,13 +12106,13 @@ public interface AggregationOrBuilder extends
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
          * @return The reference.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference();
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder();
 
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.AggregationCase getAggregationCase();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.AggregationCase getAggregationCase();
       }
       /**
        * Protobuf type {@code weaviate.v1.AggregateReply.Aggregations.Aggregation}
@@ -12139,15 +12139,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder.class);
         }
 
         public interface IntegerOrBuilder extends
@@ -12273,15 +12273,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder.class);
           }
 
           private int bitField0_;
@@ -12553,10 +12553,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) obj;
 
             if (hasCount() != other.hasCount()) return false;
             if (hasCount()) {
@@ -12655,44 +12655,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -12700,26 +12700,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -12732,7 +12732,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -12753,21 +12753,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.newBuilder()
             private Builder() {
 
             }
@@ -12795,17 +12795,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Integer_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -12813,14 +12813,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -12892,16 +12892,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance()) return this;
               if (other.hasCount()) {
                 setCount(other.getCount());
               }
@@ -13386,12 +13386,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -13427,7 +13427,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -13556,15 +13556,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder.class);
           }
 
           private int bitField0_;
@@ -13836,10 +13836,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) obj;
 
             if (hasCount() != other.hasCount()) return false;
             if (hasCount()) {
@@ -13942,44 +13942,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -13987,26 +13987,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -14019,7 +14019,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -14040,21 +14040,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Number)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.newBuilder()
             private Builder() {
 
             }
@@ -14082,17 +14082,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Number_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -14100,14 +14100,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -14179,16 +14179,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance()) return this;
               if (other.hasCount()) {
                 setCount(other.getCount());
               }
@@ -14673,12 +14673,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Number)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -14714,7 +14714,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -14761,11 +14761,11 @@ public interface TextOrBuilder extends
            * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
            * @return The topOccurences.
            */
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences();
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences();
           /**
            * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
            */
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder();
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder();
         }
         /**
          * Protobuf type {@code weaviate.v1.AggregateReply.Aggregations.Aggregation.Text}
@@ -14792,15 +14792,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder.class);
           }
 
           public interface TopOccurrencesOrBuilder extends
@@ -14810,12 +14810,12 @@ public interface TopOccurrencesOrBuilder extends
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
-            java.util.List 
+            java.util.List 
                 getItemsList();
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index);
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index);
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
@@ -14823,12 +14823,12 @@ public interface TopOccurrencesOrBuilder extends
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
-            java.util.List 
+            java.util.List 
                 getItemsOrBuilderList();
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
                 int index);
           }
           /**
@@ -14856,15 +14856,15 @@ protected java.lang.Object newInstance(
 
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder.class);
             }
 
             public interface TopOccurrenceOrBuilder extends
@@ -14914,15 +14914,15 @@ protected java.lang.Object newInstance(
 
               public static final com.google.protobuf.Descriptors.Descriptor
                   getDescriptor() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
               }
 
               @java.lang.Override
               protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                   internalGetFieldAccessorTable() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_fieldAccessorTable
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_fieldAccessorTable
                     .ensureFieldAccessorsInitialized(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder.class);
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder.class);
               }
 
               public static final int VALUE_FIELD_NUMBER = 1;
@@ -15021,10 +15021,10 @@ public boolean equals(final java.lang.Object obj) {
                 if (obj == this) {
                  return true;
                 }
-                if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)) {
+                if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)) {
                   return super.equals(obj);
                 }
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence) obj;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence) obj;
 
                 if (!getValue()
                     .equals(other.getValue())) return false;
@@ -15051,44 +15051,44 @@ public int hashCode() {
                 return hash;
               }
 
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   java.nio.ByteBuffer data)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   java.nio.ByteBuffer data,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data, extensionRegistry);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   com.google.protobuf.ByteString data)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   com.google.protobuf.ByteString data,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data, extensionRegistry);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(byte[] data)
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(byte[] data)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   byte[] data,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws com.google.protobuf.InvalidProtocolBufferException {
                 return PARSER.parseFrom(data, extensionRegistry);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(java.io.InputStream input)
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(java.io.InputStream input)
                   throws java.io.IOException {
                 return com.google.protobuf.GeneratedMessageV3
                     .parseWithIOException(PARSER, input);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   java.io.InputStream input,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws java.io.IOException {
@@ -15096,26 +15096,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                     .parseWithIOException(PARSER, input, extensionRegistry);
               }
 
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseDelimitedFrom(java.io.InputStream input)
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseDelimitedFrom(java.io.InputStream input)
                   throws java.io.IOException {
                 return com.google.protobuf.GeneratedMessageV3
                     .parseDelimitedWithIOException(PARSER, input);
               }
 
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseDelimitedFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseDelimitedFrom(
                   java.io.InputStream input,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws java.io.IOException {
                 return com.google.protobuf.GeneratedMessageV3
                     .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   com.google.protobuf.CodedInputStream input)
                   throws java.io.IOException {
                 return com.google.protobuf.GeneratedMessageV3
                     .parseWithIOException(PARSER, input);
               }
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence parseFrom(
                   com.google.protobuf.CodedInputStream input,
                   com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                   throws java.io.IOException {
@@ -15128,7 +15128,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               public static Builder newBuilder() {
                 return DEFAULT_INSTANCE.toBuilder();
               }
-              public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence prototype) {
+              public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence prototype) {
                 return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
               }
               @java.lang.Override
@@ -15149,21 +15149,21 @@ protected Builder newBuilderForType(
               public static final class Builder extends
                   com.google.protobuf.GeneratedMessageV3.Builder implements
                   // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder {
                 public static final com.google.protobuf.Descriptors.Descriptor
                     getDescriptor() {
-                  return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
+                  return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
                 }
 
                 @java.lang.Override
                 protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                     internalGetFieldAccessorTable() {
-                  return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_fieldAccessorTable
+                  return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_fieldAccessorTable
                       .ensureFieldAccessorsInitialized(
-                          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder.class);
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder.class);
                 }
 
-                // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.newBuilder()
+                // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.newBuilder()
                 private Builder() {
 
                 }
@@ -15185,17 +15185,17 @@ public Builder clear() {
                 @java.lang.Override
                 public com.google.protobuf.Descriptors.Descriptor
                     getDescriptorForType() {
-                  return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
+                  return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_TopOccurrence_descriptor;
                 }
 
                 @java.lang.Override
-                public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstanceForType() {
-                  return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance();
+                public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstanceForType() {
+                  return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance();
                 }
 
                 @java.lang.Override
-                public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence build() {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result = buildPartial();
+                public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence build() {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result = buildPartial();
                   if (!result.isInitialized()) {
                     throw newUninitializedMessageException(result);
                   }
@@ -15203,14 +15203,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
                 }
 
                 @java.lang.Override
-                public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence buildPartial() {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence(this);
+                public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence buildPartial() {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence(this);
                   if (bitField0_ != 0) { buildPartial0(result); }
                   onBuilt();
                   return result;
                 }
 
-                private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result) {
+                private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence result) {
                   int from_bitField0_ = bitField0_;
                   if (((from_bitField0_ & 0x00000001) != 0)) {
                     result.value_ = value_;
@@ -15254,16 +15254,16 @@ public Builder addRepeatedField(
                 }
                 @java.lang.Override
                 public Builder mergeFrom(com.google.protobuf.Message other) {
-                  if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence) {
-                    return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)other);
+                  if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence) {
+                    return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)other);
                   } else {
                     super.mergeFrom(other);
                     return this;
                   }
                 }
 
-                public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence other) {
-                  if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance()) return this;
+                public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence other) {
+                  if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance()) return this;
                   if (!other.getValue().isEmpty()) {
                     value_ = other.value_;
                     bitField0_ |= 0x00000001;
@@ -15445,12 +15445,12 @@ public final Builder mergeUnknownFields(
               }
 
               // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence)
-              private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence DEFAULT_INSTANCE;
+              private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence DEFAULT_INSTANCE;
               static {
-                DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence();
+                DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence();
               }
 
-              public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstance() {
+              public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstance() {
                 return DEFAULT_INSTANCE;
               }
 
@@ -15486,7 +15486,7 @@ public com.google.protobuf.Parser getParserForType() {
               }
 
               @java.lang.Override
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstanceForType() {
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getDefaultInstanceForType() {
                 return DEFAULT_INSTANCE;
               }
 
@@ -15494,19 +15494,19 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
 
             public static final int ITEMS_FIELD_NUMBER = 1;
             @SuppressWarnings("serial")
-            private java.util.List items_;
+            private java.util.List items_;
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
             @java.lang.Override
-            public java.util.List getItemsList() {
+            public java.util.List getItemsList() {
               return items_;
             }
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
             @java.lang.Override
-            public java.util.List 
+            public java.util.List 
                 getItemsOrBuilderList() {
               return items_;
             }
@@ -15521,14 +15521,14 @@ public int getItemsCount() {
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index) {
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index) {
               return items_.get(index);
             }
             /**
              * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
              */
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
                 int index) {
               return items_.get(index);
             }
@@ -15573,10 +15573,10 @@ public boolean equals(final java.lang.Object obj) {
               if (obj == this) {
                return true;
               }
-              if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)) {
+              if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)) {
                 return super.equals(obj);
               }
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences) obj;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences) obj;
 
               if (!getItemsList()
                   .equals(other.getItemsList())) return false;
@@ -15600,44 +15600,44 @@ public int hashCode() {
               return hash;
             }
 
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 java.nio.ByteBuffer data)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 java.nio.ByteBuffer data,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data, extensionRegistry);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 com.google.protobuf.ByteString data)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 com.google.protobuf.ByteString data,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data, extensionRegistry);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(byte[] data)
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(byte[] data)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 byte[] data,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws com.google.protobuf.InvalidProtocolBufferException {
               return PARSER.parseFrom(data, extensionRegistry);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(java.io.InputStream input)
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(java.io.InputStream input)
                 throws java.io.IOException {
               return com.google.protobuf.GeneratedMessageV3
                   .parseWithIOException(PARSER, input);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 java.io.InputStream input,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws java.io.IOException {
@@ -15645,26 +15645,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                   .parseWithIOException(PARSER, input, extensionRegistry);
             }
 
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseDelimitedFrom(java.io.InputStream input)
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseDelimitedFrom(java.io.InputStream input)
                 throws java.io.IOException {
               return com.google.protobuf.GeneratedMessageV3
                   .parseDelimitedWithIOException(PARSER, input);
             }
 
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseDelimitedFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseDelimitedFrom(
                 java.io.InputStream input,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws java.io.IOException {
               return com.google.protobuf.GeneratedMessageV3
                   .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 com.google.protobuf.CodedInputStream input)
                 throws java.io.IOException {
               return com.google.protobuf.GeneratedMessageV3
                   .parseWithIOException(PARSER, input);
             }
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences parseFrom(
                 com.google.protobuf.CodedInputStream input,
                 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                 throws java.io.IOException {
@@ -15677,7 +15677,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             public static Builder newBuilder() {
               return DEFAULT_INSTANCE.toBuilder();
             }
-            public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences prototype) {
+            public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences prototype) {
               return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
             }
             @java.lang.Override
@@ -15698,21 +15698,21 @@ protected Builder newBuilderForType(
             public static final class Builder extends
                 com.google.protobuf.GeneratedMessageV3.Builder implements
                 // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder {
               public static final com.google.protobuf.Descriptors.Descriptor
                   getDescriptor() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
               }
 
               @java.lang.Override
               protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                   internalGetFieldAccessorTable() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_fieldAccessorTable
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_fieldAccessorTable
                     .ensureFieldAccessorsInitialized(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder.class);
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder.class);
               }
 
-              // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.newBuilder()
+              // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.newBuilder()
               private Builder() {
 
               }
@@ -15739,17 +15739,17 @@ public Builder clear() {
               @java.lang.Override
               public com.google.protobuf.Descriptors.Descriptor
                   getDescriptorForType() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_TopOccurrences_descriptor;
               }
 
               @java.lang.Override
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstanceForType() {
-                return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance();
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstanceForType() {
+                return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance();
               }
 
               @java.lang.Override
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences build() {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result = buildPartial();
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences build() {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result = buildPartial();
                 if (!result.isInitialized()) {
                   throw newUninitializedMessageException(result);
                 }
@@ -15757,15 +15757,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
               }
 
               @java.lang.Override
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences buildPartial() {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences(this);
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences buildPartial() {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences(this);
                 buildPartialRepeatedFields(result);
                 if (bitField0_ != 0) { buildPartial0(result); }
                 onBuilt();
                 return result;
               }
 
-              private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result) {
+              private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result) {
                 if (itemsBuilder_ == null) {
                   if (((bitField0_ & 0x00000001) != 0)) {
                     items_ = java.util.Collections.unmodifiableList(items_);
@@ -15777,7 +15777,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
                 }
               }
 
-              private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result) {
+              private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences result) {
                 int from_bitField0_ = bitField0_;
               }
 
@@ -15815,16 +15815,16 @@ public Builder addRepeatedField(
               }
               @java.lang.Override
               public Builder mergeFrom(com.google.protobuf.Message other) {
-                if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences) {
-                  return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)other);
+                if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences) {
+                  return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)other);
                 } else {
                   super.mergeFrom(other);
                   return this;
                 }
               }
 
-              public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences other) {
-                if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance()) return this;
+              public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences other) {
+                if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance()) return this;
                 if (itemsBuilder_ == null) {
                   if (!other.items_.isEmpty()) {
                     if (items_.isEmpty()) {
@@ -15878,9 +15878,9 @@ public Builder mergeFrom(
                         done = true;
                         break;
                       case 10: {
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence m =
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence m =
                             input.readMessage(
-                                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.parser(),
+                                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.parser(),
                                 extensionRegistry);
                         if (itemsBuilder_ == null) {
                           ensureItemsIsMutable();
@@ -15907,22 +15907,22 @@ public Builder mergeFrom(
               }
               private int bitField0_;
 
-              private java.util.List items_ =
+              private java.util.List items_ =
                 java.util.Collections.emptyList();
               private void ensureItemsIsMutable() {
                 if (!((bitField0_ & 0x00000001) != 0)) {
-                  items_ = new java.util.ArrayList(items_);
+                  items_ = new java.util.ArrayList(items_);
                   bitField0_ |= 0x00000001;
                  }
               }
 
               private com.google.protobuf.RepeatedFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder> itemsBuilder_;
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder> itemsBuilder_;
 
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public java.util.List getItemsList() {
+              public java.util.List getItemsList() {
                 if (itemsBuilder_ == null) {
                   return java.util.Collections.unmodifiableList(items_);
                 } else {
@@ -15942,7 +15942,7 @@ public int getItemsCount() {
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index) {
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence getItems(int index) {
                 if (itemsBuilder_ == null) {
                   return items_.get(index);
                 } else {
@@ -15953,7 +15953,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder setItems(
-                  int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
+                  int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
                 if (itemsBuilder_ == null) {
                   if (value == null) {
                     throw new NullPointerException();
@@ -15970,7 +15970,7 @@ public Builder setItems(
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder setItems(
-                  int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
+                  int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
                 if (itemsBuilder_ == null) {
                   ensureItemsIsMutable();
                   items_.set(index, builderForValue.build());
@@ -15983,7 +15983,7 @@ public Builder setItems(
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public Builder addItems(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
+              public Builder addItems(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
                 if (itemsBuilder_ == null) {
                   if (value == null) {
                     throw new NullPointerException();
@@ -16000,7 +16000,7 @@ public Builder addItems(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggrega
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder addItems(
-                  int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
+                  int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence value) {
                 if (itemsBuilder_ == null) {
                   if (value == null) {
                     throw new NullPointerException();
@@ -16017,7 +16017,7 @@ public Builder addItems(
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder addItems(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
                 if (itemsBuilder_ == null) {
                   ensureItemsIsMutable();
                   items_.add(builderForValue.build());
@@ -16031,7 +16031,7 @@ public Builder addItems(
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder addItems(
-                  int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
+                  int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder builderForValue) {
                 if (itemsBuilder_ == null) {
                   ensureItemsIsMutable();
                   items_.add(index, builderForValue.build());
@@ -16045,7 +16045,7 @@ public Builder addItems(
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
               public Builder addAllItems(
-                  java.lang.Iterable values) {
+                  java.lang.Iterable values) {
                 if (itemsBuilder_ == null) {
                   ensureItemsIsMutable();
                   com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -16085,14 +16085,14 @@ public Builder removeItems(int index) {
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder getItemsBuilder(
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder getItemsBuilder(
                   int index) {
                 return getItemsFieldBuilder().getBuilder(index);
               }
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder getItemsOrBuilder(
                   int index) {
                 if (itemsBuilder_ == null) {
                   return items_.get(index);  } else {
@@ -16102,7 +16102,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public java.util.List 
+              public java.util.List 
                    getItemsOrBuilderList() {
                 if (itemsBuilder_ != null) {
                   return itemsBuilder_.getMessageOrBuilderList();
@@ -16113,31 +16113,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder addItemsBuilder() {
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder addItemsBuilder() {
                 return getItemsFieldBuilder().addBuilder(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance());
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance());
               }
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder addItemsBuilder(
+              public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder addItemsBuilder(
                   int index) {
                 return getItemsFieldBuilder().addBuilder(
-                    index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance());
+                    index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.getDefaultInstance());
               }
               /**
                * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence items = 1;
                */
-              public java.util.List 
+              public java.util.List 
                    getItemsBuilderList() {
                 return getItemsFieldBuilder().getBuilderList();
               }
               private com.google.protobuf.RepeatedFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder> 
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder> 
                   getItemsFieldBuilder() {
                 if (itemsBuilder_ == null) {
                   itemsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder>(
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrence.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.TopOccurrenceOrBuilder>(
                           items_,
                           ((bitField0_ & 0x00000001) != 0),
                           getParentForChildren(),
@@ -16163,12 +16163,12 @@ public final Builder mergeUnknownFields(
             }
 
             // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences)
-            private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences DEFAULT_INSTANCE;
+            private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences DEFAULT_INSTANCE;
             static {
-              DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences();
+              DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences();
             }
 
-            public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstance() {
+            public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstance() {
               return DEFAULT_INSTANCE;
             }
 
@@ -16204,7 +16204,7 @@ public com.google.protobuf.Parser getParserForType() {
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstanceForType() {
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getDefaultInstanceForType() {
               return DEFAULT_INSTANCE;
             }
 
@@ -16278,7 +16278,7 @@ public java.lang.String getType() {
           }
 
           public static final int TOP_OCCURENCES_FIELD_NUMBER = 3;
-          private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences topOccurences_;
+          private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences topOccurences_;
           /**
            * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
            * @return Whether the topOccurences field is set.
@@ -16292,15 +16292,15 @@ public boolean hasTopOccurences() {
            * @return The topOccurences.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences() {
-            return topOccurences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences() {
+            return topOccurences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
           }
           /**
            * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder() {
-            return topOccurences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder() {
+            return topOccurences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
           }
 
           private byte memoizedIsInitialized = -1;
@@ -16356,10 +16356,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) obj;
 
             if (hasCount() != other.hasCount()) return false;
             if (hasCount()) {
@@ -16405,44 +16405,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -16450,26 +16450,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -16482,7 +16482,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -16503,21 +16503,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.newBuilder()
             private Builder() {
               maybeForceBuilderInitialization();
             }
@@ -16550,17 +16550,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Text_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -16568,14 +16568,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -16629,16 +16629,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance()) return this;
               if (other.hasCount()) {
                 setCount(other.getCount());
               }
@@ -16829,9 +16829,9 @@ public Builder setTypeBytes(
               return this;
             }
 
-            private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences topOccurences_;
+            private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences topOccurences_;
             private com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder> topOccurencesBuilder_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder> topOccurencesBuilder_;
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              * @return Whether the topOccurences field is set.
@@ -16843,9 +16843,9 @@ public boolean hasTopOccurences() {
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              * @return The topOccurences.
              */
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences() {
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences getTopOccurences() {
               if (topOccurencesBuilder_ == null) {
-                return topOccurences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
+                return topOccurences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
               } else {
                 return topOccurencesBuilder_.getMessage();
               }
@@ -16853,7 +16853,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
-            public Builder setTopOccurences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences value) {
+            public Builder setTopOccurences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences value) {
               if (topOccurencesBuilder_ == null) {
                 if (value == null) {
                   throw new NullPointerException();
@@ -16870,7 +16870,7 @@ public Builder setTopOccurences(io.weaviate.client.grpc.protocol.v1.WeaviateProt
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
             public Builder setTopOccurences(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder builderForValue) {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder builderForValue) {
               if (topOccurencesBuilder_ == null) {
                 topOccurences_ = builderForValue.build();
               } else {
@@ -16883,11 +16883,11 @@ public Builder setTopOccurences(
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
-            public Builder mergeTopOccurences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences value) {
+            public Builder mergeTopOccurences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences value) {
               if (topOccurencesBuilder_ == null) {
                 if (((bitField0_ & 0x00000004) != 0) &&
                   topOccurences_ != null &&
-                  topOccurences_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance()) {
+                  topOccurences_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance()) {
                   getTopOccurencesBuilder().mergeFrom(value);
                 } else {
                   topOccurences_ = value;
@@ -16917,7 +16917,7 @@ public Builder clearTopOccurences() {
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder getTopOccurencesBuilder() {
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder getTopOccurencesBuilder() {
               bitField0_ |= 0x00000004;
               onChanged();
               return getTopOccurencesFieldBuilder().getBuilder();
@@ -16925,23 +16925,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder() {
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder getTopOccurencesOrBuilder() {
               if (topOccurencesBuilder_ != null) {
                 return topOccurencesBuilder_.getMessageOrBuilder();
               } else {
                 return topOccurences_ == null ?
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.getDefaultInstance() : topOccurences_;
               }
             }
             /**
              * optional .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences top_occurences = 3;
              */
             private com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder> 
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder> 
                 getTopOccurencesFieldBuilder() {
               if (topOccurencesBuilder_ == null) {
                 topOccurencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder>(
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrences.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.TopOccurrencesOrBuilder>(
                         getTopOccurences(),
                         getParentForChildren(),
                         isClean());
@@ -16966,12 +16966,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Text)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -17007,7 +17007,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -17114,15 +17114,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder.class);
           }
 
           private int bitField0_;
@@ -17342,10 +17342,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) obj;
 
             if (hasCount() != other.hasCount()) return false;
             if (hasCount()) {
@@ -17424,44 +17424,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -17469,26 +17469,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -17501,7 +17501,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -17522,21 +17522,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.newBuilder()
             private Builder() {
 
             }
@@ -17562,17 +17562,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Boolean_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -17580,14 +17580,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -17651,16 +17651,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance()) return this;
               if (other.hasCount()) {
                 setCount(other.getCount());
               }
@@ -18049,12 +18049,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -18090,7 +18090,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -18225,15 +18225,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder.class);
           }
 
           private int bitField0_;
@@ -18561,10 +18561,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) obj;
 
             if (hasCount() != other.hasCount()) return false;
             if (hasCount()) {
@@ -18637,44 +18637,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -18682,26 +18682,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -18714,7 +18714,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -18735,21 +18735,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Date)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.newBuilder()
             private Builder() {
 
             }
@@ -18775,17 +18775,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Date_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -18793,14 +18793,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -18864,16 +18864,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance()) return this;
               if (other.hasCount()) {
                 setCount(other.getCount());
               }
@@ -19426,12 +19426,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Date)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -19467,7 +19467,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -19562,15 +19562,15 @@ protected java.lang.Object newInstance(
 
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder.class);
           }
 
           private int bitField0_;
@@ -19724,10 +19724,10 @@ public boolean equals(final java.lang.Object obj) {
             if (obj == this) {
              return true;
             }
-            if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference)) {
+            if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference)) {
               return super.equals(obj);
             }
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) obj;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) obj;
 
             if (hasType() != other.hasType()) return false;
             if (hasType()) {
@@ -19760,44 +19760,44 @@ public int hashCode() {
             return hash;
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               java.nio.ByteBuffer data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               java.nio.ByteBuffer data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               com.google.protobuf.ByteString data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               com.google.protobuf.ByteString data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(byte[] data)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(byte[] data)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               byte[] data,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws com.google.protobuf.InvalidProtocolBufferException {
             return PARSER.parseFrom(data, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -19805,26 +19805,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
                 .parseWithIOException(PARSER, input, extensionRegistry);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseDelimitedFrom(java.io.InputStream input)
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseDelimitedFrom(java.io.InputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input);
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseDelimitedFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseDelimitedFrom(
               java.io.InputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               com.google.protobuf.CodedInputStream input)
               throws java.io.IOException {
             return com.google.protobuf.GeneratedMessageV3
                 .parseWithIOException(PARSER, input);
           }
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference parseFrom(
               com.google.protobuf.CodedInputStream input,
               com.google.protobuf.ExtensionRegistryLite extensionRegistry)
               throws java.io.IOException {
@@ -19837,7 +19837,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           public static Builder newBuilder() {
             return DEFAULT_INSTANCE.toBuilder();
           }
-          public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference prototype) {
+          public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference prototype) {
             return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
           }
           @java.lang.Override
@@ -19858,21 +19858,21 @@ protected Builder newBuilderForType(
           public static final class Builder extends
               com.google.protobuf.GeneratedMessageV3.Builder implements
               // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference)
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder {
             public static final com.google.protobuf.Descriptors.Descriptor
                 getDescriptor() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
             }
 
             @java.lang.Override
             protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
                 internalGetFieldAccessorTable() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_fieldAccessorTable
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_fieldAccessorTable
                   .ensureFieldAccessorsInitialized(
-                      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder.class);
+                      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder.class);
             }
 
-            // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.newBuilder()
+            // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.newBuilder()
             private Builder() {
 
             }
@@ -19895,17 +19895,17 @@ public Builder clear() {
             @java.lang.Override
             public com.google.protobuf.Descriptors.Descriptor
                 getDescriptorForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_Reference_descriptor;
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstanceForType() {
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstanceForType() {
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference build() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result = buildPartial();
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference build() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result = buildPartial();
               if (!result.isInitialized()) {
                 throw newUninitializedMessageException(result);
               }
@@ -19913,14 +19913,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
             }
 
             @java.lang.Override
-            public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference buildPartial() {
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference(this);
+            public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference buildPartial() {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference(this);
               if (bitField0_ != 0) { buildPartial0(result); }
               onBuilt();
               return result;
             }
 
-            private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result) {
+            private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference result) {
               int from_bitField0_ = bitField0_;
               int to_bitField0_ = 0;
               if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -19968,16 +19968,16 @@ public Builder addRepeatedField(
             }
             @java.lang.Override
             public Builder mergeFrom(com.google.protobuf.Message other) {
-              if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) {
-                return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference)other);
+              if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) {
+                return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference)other);
               } else {
                 super.mergeFrom(other);
                 return this;
               }
             }
 
-            public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference other) {
-              if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance()) return this;
+            public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference other) {
+              if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance()) return this;
               if (other.hasType()) {
                 type_ = other.type_;
                 bitField0_ |= 0x00000001;
@@ -20289,12 +20289,12 @@ public final Builder mergeUnknownFields(
           }
 
           // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference)
-          private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference DEFAULT_INSTANCE;
+          private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference DEFAULT_INSTANCE;
           static {
-            DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference();
+            DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference();
           }
 
-          public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstance() {
+          public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstance() {
             return DEFAULT_INSTANCE;
           }
 
@@ -20330,7 +20330,7 @@ public com.google.protobuf.Parser getParserForType() {
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstanceForType() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getDefaultInstanceForType() {
             return DEFAULT_INSTANCE;
           }
 
@@ -20439,21 +20439,21 @@ public boolean hasInt() {
          * @return The int.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt() {
           if (aggregationCase_ == 2) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder() {
           if (aggregationCase_ == 2) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
         }
 
         public static final int NUMBER_FIELD_NUMBER = 3;
@@ -20470,21 +20470,21 @@ public boolean hasNumber() {
          * @return The number.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber() {
           if (aggregationCase_ == 3) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder() {
           if (aggregationCase_ == 3) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
         }
 
         public static final int TEXT_FIELD_NUMBER = 4;
@@ -20501,21 +20501,21 @@ public boolean hasText() {
          * @return The text.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText() {
           if (aggregationCase_ == 4) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder() {
           if (aggregationCase_ == 4) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
         }
 
         public static final int BOOLEAN_FIELD_NUMBER = 5;
@@ -20532,21 +20532,21 @@ public boolean hasBoolean() {
          * @return The boolean.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean() {
           if (aggregationCase_ == 5) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
           if (aggregationCase_ == 5) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
         }
 
         public static final int DATE_FIELD_NUMBER = 6;
@@ -20563,21 +20563,21 @@ public boolean hasDate() {
          * @return The date.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate() {
           if (aggregationCase_ == 6) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder() {
           if (aggregationCase_ == 6) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
         }
 
         public static final int REFERENCE_FIELD_NUMBER = 7;
@@ -20594,21 +20594,21 @@ public boolean hasReference() {
          * @return The reference.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference() {
           if (aggregationCase_ == 7) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
         }
         /**
          * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
           if (aggregationCase_ == 7) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
         }
 
         private byte memoizedIsInitialized = -1;
@@ -20629,22 +20629,22 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
             com.google.protobuf.GeneratedMessageV3.writeString(output, 1, property_);
           }
           if (aggregationCase_ == 2) {
-            output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_);
+            output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_);
           }
           if (aggregationCase_ == 3) {
-            output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_);
+            output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_);
           }
           if (aggregationCase_ == 4) {
-            output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_);
+            output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_);
           }
           if (aggregationCase_ == 5) {
-            output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_);
+            output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_);
           }
           if (aggregationCase_ == 6) {
-            output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_);
+            output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_);
           }
           if (aggregationCase_ == 7) {
-            output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_);
+            output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_);
           }
           getUnknownFields().writeTo(output);
         }
@@ -20660,27 +20660,27 @@ public int getSerializedSize() {
           }
           if (aggregationCase_ == 2) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_);
+              .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_);
           }
           if (aggregationCase_ == 3) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_);
+              .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_);
           }
           if (aggregationCase_ == 4) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_);
+              .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_);
           }
           if (aggregationCase_ == 5) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_);
+              .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_);
           }
           if (aggregationCase_ == 6) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_);
+              .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_);
           }
           if (aggregationCase_ == 7) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_);
+              .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_);
           }
           size += getUnknownFields().getSerializedSize();
           memoizedSize = size;
@@ -20692,10 +20692,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation) obj;
 
           if (!getProperty()
               .equals(other.getProperty())) return false;
@@ -20774,44 +20774,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -20819,26 +20819,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -20851,7 +20851,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -20872,21 +20872,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations.Aggregation)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.newBuilder()
           private Builder() {
 
           }
@@ -20927,17 +20927,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_Aggregation_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -20945,22 +20945,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             buildPartialOneofs(result);
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               result.property_ = property_;
             }
           }
 
-          private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result) {
+          private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation result) {
             result.aggregationCase_ = aggregationCase_;
             result.aggregation_ = this.aggregation_;
             if (aggregationCase_ == 2 &&
@@ -21023,16 +21023,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance()) return this;
             if (!other.getProperty().isEmpty()) {
               property_ = other.property_;
               bitField0_ |= 0x00000001;
@@ -21245,7 +21245,7 @@ public Builder setPropertyBytes(
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder> intBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder> intBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            * @return Whether the int field is set.
@@ -21259,23 +21259,23 @@ public boolean hasInt() {
            * @return The int.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer getInt() {
             if (intBuilder_ == null) {
               if (aggregationCase_ == 2) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
             } else {
               if (aggregationCase_ == 2) {
                 return intBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
-          public Builder setInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer value) {
+          public Builder setInt(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer value) {
             if (intBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -21292,7 +21292,7 @@ public Builder setInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
           public Builder setInt(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder builderForValue) {
             if (intBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -21305,11 +21305,11 @@ public Builder setInt(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
-          public Builder mergeInt(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer value) {
+          public Builder mergeInt(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer value) {
             if (intBuilder_ == null) {
               if (aggregationCase_ == 2 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -21347,36 +21347,36 @@ public Builder clearInt() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder getIntBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder getIntBuilder() {
             return getIntFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder getIntOrBuilder() {
             if ((aggregationCase_ == 2) && (intBuilder_ != null)) {
               return intBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 2) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Integer int = 2;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder> 
               getIntFieldBuilder() {
             if (intBuilder_ == null) {
               if (!(aggregationCase_ == 2)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.getDefaultInstance();
               }
               intBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.IntegerOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Integer) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -21387,7 +21387,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder> numberBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder> numberBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            * @return Whether the number field is set.
@@ -21401,23 +21401,23 @@ public boolean hasNumber() {
            * @return The number.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number getNumber() {
             if (numberBuilder_ == null) {
               if (aggregationCase_ == 3) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
             } else {
               if (aggregationCase_ == 3) {
                 return numberBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
-          public Builder setNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number value) {
+          public Builder setNumber(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number value) {
             if (numberBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -21434,7 +21434,7 @@ public Builder setNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggreg
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
           public Builder setNumber(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder builderForValue) {
             if (numberBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -21447,11 +21447,11 @@ public Builder setNumber(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
-          public Builder mergeNumber(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number value) {
+          public Builder mergeNumber(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number value) {
             if (numberBuilder_ == null) {
               if (aggregationCase_ == 3 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -21489,36 +21489,36 @@ public Builder clearNumber() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder getNumberBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder getNumberBuilder() {
             return getNumberFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder getNumberOrBuilder() {
             if ((aggregationCase_ == 3) && (numberBuilder_ != null)) {
               return numberBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 3) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Number number = 3;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder> 
               getNumberFieldBuilder() {
             if (numberBuilder_ == null) {
               if (!(aggregationCase_ == 3)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.getDefaultInstance();
               }
               numberBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.NumberOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Number) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -21529,7 +21529,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder> textBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder> textBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            * @return Whether the text field is set.
@@ -21543,23 +21543,23 @@ public boolean hasText() {
            * @return The text.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text getText() {
             if (textBuilder_ == null) {
               if (aggregationCase_ == 4) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
             } else {
               if (aggregationCase_ == 4) {
                 return textBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
-          public Builder setText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text value) {
+          public Builder setText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text value) {
             if (textBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -21576,7 +21576,7 @@ public Builder setText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregat
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
           public Builder setText(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder builderForValue) {
             if (textBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -21589,11 +21589,11 @@ public Builder setText(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
-          public Builder mergeText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text value) {
+          public Builder mergeText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text value) {
             if (textBuilder_ == null) {
               if (aggregationCase_ == 4 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -21631,36 +21631,36 @@ public Builder clearText() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder getTextBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder getTextBuilder() {
             return getTextFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder getTextOrBuilder() {
             if ((aggregationCase_ == 4) && (textBuilder_ != null)) {
               return textBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 4) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Text text = 4;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder> 
               getTextFieldBuilder() {
             if (textBuilder_ == null) {
               if (!(aggregationCase_ == 4)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.getDefaultInstance();
               }
               textBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.TextOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Text) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -21671,7 +21671,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder> booleanBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder> booleanBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            * @return Whether the boolean field is set.
@@ -21685,23 +21685,23 @@ public boolean hasBoolean() {
            * @return The boolean.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean getBoolean() {
             if (booleanBuilder_ == null) {
               if (aggregationCase_ == 5) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
             } else {
               if (aggregationCase_ == 5) {
                 return booleanBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
-          public Builder setBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean value) {
+          public Builder setBoolean(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean value) {
             if (booleanBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -21718,7 +21718,7 @@ public Builder setBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggre
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
           public Builder setBoolean(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder builderForValue) {
             if (booleanBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -21731,11 +21731,11 @@ public Builder setBoolean(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
-          public Builder mergeBoolean(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean value) {
+          public Builder mergeBoolean(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean value) {
             if (booleanBuilder_ == null) {
               if (aggregationCase_ == 5 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -21773,36 +21773,36 @@ public Builder clearBoolean() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder getBooleanBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder getBooleanBuilder() {
             return getBooleanFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder getBooleanOrBuilder() {
             if ((aggregationCase_ == 5) && (booleanBuilder_ != null)) {
               return booleanBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 5) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Boolean boolean = 5;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder> 
               getBooleanFieldBuilder() {
             if (booleanBuilder_ == null) {
               if (!(aggregationCase_ == 5)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.getDefaultInstance();
               }
               booleanBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.BooleanOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Boolean) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -21813,7 +21813,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder> dateBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder> dateBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            * @return Whether the date field is set.
@@ -21827,23 +21827,23 @@ public boolean hasDate() {
            * @return The date.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date getDate() {
             if (dateBuilder_ == null) {
               if (aggregationCase_ == 6) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
             } else {
               if (aggregationCase_ == 6) {
                 return dateBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
-          public Builder setDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date value) {
+          public Builder setDate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date value) {
             if (dateBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -21860,7 +21860,7 @@ public Builder setDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregat
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
           public Builder setDate(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder builderForValue) {
             if (dateBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -21873,11 +21873,11 @@ public Builder setDate(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
-          public Builder mergeDate(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date value) {
+          public Builder mergeDate(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date value) {
             if (dateBuilder_ == null) {
               if (aggregationCase_ == 6 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -21915,36 +21915,36 @@ public Builder clearDate() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder getDateBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder getDateBuilder() {
             return getDateFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder getDateOrBuilder() {
             if ((aggregationCase_ == 6) && (dateBuilder_ != null)) {
               return dateBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 6) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Date date = 6;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder> 
               getDateFieldBuilder() {
             if (dateBuilder_ == null) {
               if (!(aggregationCase_ == 6)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.getDefaultInstance();
               }
               dateBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.DateOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Date) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -21955,7 +21955,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder> referenceBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder> referenceBuilder_;
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            * @return Whether the reference field is set.
@@ -21969,23 +21969,23 @@ public boolean hasReference() {
            * @return The reference.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference getReference() {
             if (referenceBuilder_ == null) {
               if (aggregationCase_ == 7) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
             } else {
               if (aggregationCase_ == 7) {
                 return referenceBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
-          public Builder setReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference value) {
+          public Builder setReference(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference value) {
             if (referenceBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -22002,7 +22002,7 @@ public Builder setReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAgg
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
           public Builder setReference(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder builderForValue) {
             if (referenceBuilder_ == null) {
               aggregation_ = builderForValue.build();
               onChanged();
@@ -22015,11 +22015,11 @@ public Builder setReference(
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
-          public Builder mergeReference(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference value) {
+          public Builder mergeReference(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference value) {
             if (referenceBuilder_ == null) {
               if (aggregationCase_ == 7 &&
-                  aggregation_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance()) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_)
+                  aggregation_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance()) {
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_)
                     .mergeFrom(value).buildPartial();
               } else {
                 aggregation_ = value;
@@ -22057,36 +22057,36 @@ public Builder clearReference() {
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder getReferenceBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder getReferenceBuilder() {
             return getReferenceFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder getReferenceOrBuilder() {
             if ((aggregationCase_ == 7) && (referenceBuilder_ != null)) {
               return referenceBuilder_.getMessageOrBuilder();
             } else {
               if (aggregationCase_ == 7) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.AggregateReply.Aggregations.Aggregation.Reference reference = 7;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder> 
               getReferenceFieldBuilder() {
             if (referenceBuilder_ == null) {
               if (!(aggregationCase_ == 7)) {
-                aggregation_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
+                aggregation_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.getDefaultInstance();
               }
               referenceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.ReferenceOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Reference) aggregation_,
                       getParentForChildren(),
                       isClean());
               aggregation_ = null;
@@ -22112,12 +22112,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations.Aggregation)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -22153,7 +22153,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -22161,19 +22161,19 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
 
       public static final int AGGREGATIONS_FIELD_NUMBER = 1;
       @SuppressWarnings("serial")
-      private java.util.List aggregations_;
+      private java.util.List aggregations_;
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
       @java.lang.Override
-      public java.util.List getAggregationsList() {
+      public java.util.List getAggregationsList() {
         return aggregations_;
       }
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
       @java.lang.Override
-      public java.util.List 
+      public java.util.List 
           getAggregationsOrBuilderList() {
         return aggregations_;
       }
@@ -22188,14 +22188,14 @@ public int getAggregationsCount() {
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index) {
         return aggregations_.get(index);
       }
       /**
        * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
           int index) {
         return aggregations_.get(index);
       }
@@ -22240,10 +22240,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations) obj;
 
         if (!getAggregationsList()
             .equals(other.getAggregationsList())) return false;
@@ -22267,44 +22267,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -22312,26 +22312,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -22344,7 +22344,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -22365,21 +22365,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Aggregations)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.newBuilder()
         private Builder() {
 
         }
@@ -22406,17 +22406,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Aggregations_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -22424,15 +22424,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations(this);
           buildPartialRepeatedFields(result);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations result) {
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations result) {
           if (aggregationsBuilder_ == null) {
             if (((bitField0_ & 0x00000001) != 0)) {
               aggregations_ = java.util.Collections.unmodifiableList(aggregations_);
@@ -22444,7 +22444,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
           }
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations result) {
           int from_bitField0_ = bitField0_;
         }
 
@@ -22482,16 +22482,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) return this;
           if (aggregationsBuilder_ == null) {
             if (!other.aggregations_.isEmpty()) {
               if (aggregations_.isEmpty()) {
@@ -22545,9 +22545,9 @@ public Builder mergeFrom(
                   done = true;
                   break;
                 case 10: {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation m =
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation m =
                       input.readMessage(
-                          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.parser(),
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.parser(),
                           extensionRegistry);
                   if (aggregationsBuilder_ == null) {
                     ensureAggregationsIsMutable();
@@ -22574,22 +22574,22 @@ public Builder mergeFrom(
         }
         private int bitField0_;
 
-        private java.util.List aggregations_ =
+        private java.util.List aggregations_ =
           java.util.Collections.emptyList();
         private void ensureAggregationsIsMutable() {
           if (!((bitField0_ & 0x00000001) != 0)) {
-            aggregations_ = new java.util.ArrayList(aggregations_);
+            aggregations_ = new java.util.ArrayList(aggregations_);
             bitField0_ |= 0x00000001;
            }
         }
 
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder> aggregationsBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder> aggregationsBuilder_;
 
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public java.util.List getAggregationsList() {
+        public java.util.List getAggregationsList() {
           if (aggregationsBuilder_ == null) {
             return java.util.Collections.unmodifiableList(aggregations_);
           } else {
@@ -22609,7 +22609,7 @@ public int getAggregationsCount() {
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index) {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation getAggregations(int index) {
           if (aggregationsBuilder_ == null) {
             return aggregations_.get(index);
           } else {
@@ -22620,7 +22620,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder setAggregations(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
           if (aggregationsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -22637,7 +22637,7 @@ public Builder setAggregations(
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder setAggregations(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
           if (aggregationsBuilder_ == null) {
             ensureAggregationsIsMutable();
             aggregations_.set(index, builderForValue.build());
@@ -22650,7 +22650,7 @@ public Builder setAggregations(
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public Builder addAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
+        public Builder addAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
           if (aggregationsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -22667,7 +22667,7 @@ public Builder addAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProto
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder addAggregations(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation value) {
           if (aggregationsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -22684,7 +22684,7 @@ public Builder addAggregations(
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder addAggregations(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
           if (aggregationsBuilder_ == null) {
             ensureAggregationsIsMutable();
             aggregations_.add(builderForValue.build());
@@ -22698,7 +22698,7 @@ public Builder addAggregations(
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder addAggregations(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder builderForValue) {
           if (aggregationsBuilder_ == null) {
             ensureAggregationsIsMutable();
             aggregations_.add(index, builderForValue.build());
@@ -22712,7 +22712,7 @@ public Builder addAggregations(
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
         public Builder addAllAggregations(
-            java.lang.Iterable values) {
+            java.lang.Iterable values) {
           if (aggregationsBuilder_ == null) {
             ensureAggregationsIsMutable();
             com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -22752,14 +22752,14 @@ public Builder removeAggregations(int index) {
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder getAggregationsBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder getAggregationsBuilder(
             int index) {
           return getAggregationsFieldBuilder().getBuilder(index);
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder getAggregationsOrBuilder(
             int index) {
           if (aggregationsBuilder_ == null) {
             return aggregations_.get(index);  } else {
@@ -22769,7 +22769,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public java.util.List 
+        public java.util.List 
              getAggregationsOrBuilderList() {
           if (aggregationsBuilder_ != null) {
             return aggregationsBuilder_.getMessageOrBuilderList();
@@ -22780,31 +22780,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder addAggregationsBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder addAggregationsBuilder() {
           return getAggregationsFieldBuilder().addBuilder(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance());
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance());
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder addAggregationsBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder addAggregationsBuilder(
             int index) {
           return getAggregationsFieldBuilder().addBuilder(
-              index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance());
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.getDefaultInstance());
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Aggregations.Aggregation aggregations = 1;
          */
-        public java.util.List 
+        public java.util.List 
              getAggregationsBuilderList() {
           return getAggregationsFieldBuilder().getBuilderList();
         }
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder> 
             getAggregationsFieldBuilder() {
           if (aggregationsBuilder_ == null) {
             aggregationsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Aggregation.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.AggregationOrBuilder>(
                     aggregations_,
                     ((bitField0_ & 0x00000001) != 0),
                     getParentForChildren(),
@@ -22830,12 +22830,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Aggregations)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -22871,7 +22871,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -22901,11 +22901,11 @@ public interface SingleOrBuilder extends
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        * @return The aggregations.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations();
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder();
     }
     /**
      * Protobuf type {@code weaviate.v1.AggregateReply.Single}
@@ -22931,15 +22931,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder.class);
       }
 
       private int bitField0_;
@@ -22963,7 +22963,7 @@ public long getObjectsCount() {
       }
 
       public static final int AGGREGATIONS_FIELD_NUMBER = 2;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        * @return Whether the aggregations field is set.
@@ -22977,15 +22977,15 @@ public boolean hasAggregations() {
        * @return The aggregations.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
-        return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
+        return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
       }
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
-        return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
+        return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
       }
 
       private byte memoizedIsInitialized = -1;
@@ -23035,10 +23035,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) obj;
 
         if (hasObjectsCount() != other.hasObjectsCount()) return false;
         if (hasObjectsCount()) {
@@ -23075,44 +23075,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -23120,26 +23120,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -23152,7 +23152,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -23173,21 +23173,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Single)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.newBuilder()
         private Builder() {
           maybeForceBuilderInitialization();
         }
@@ -23219,17 +23219,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Single_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -23237,14 +23237,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -23294,16 +23294,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance()) return this;
           if (other.hasObjectsCount()) {
             setObjectsCount(other.getObjectsCount());
           }
@@ -23405,9 +23405,9 @@ public Builder clearObjectsCount() {
           return this;
         }
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> aggregationsBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> aggregationsBuilder_;
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          * @return Whether the aggregations field is set.
@@ -23419,9 +23419,9 @@ public boolean hasAggregations() {
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          * @return The aggregations.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
           if (aggregationsBuilder_ == null) {
-            return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+            return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
           } else {
             return aggregationsBuilder_.getMessage();
           }
@@ -23429,7 +23429,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public Builder setAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
+        public Builder setAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
           if (aggregationsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -23446,7 +23446,7 @@ public Builder setAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProto
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
         public Builder setAggregations(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder builderForValue) {
           if (aggregationsBuilder_ == null) {
             aggregations_ = builderForValue.build();
           } else {
@@ -23459,11 +23459,11 @@ public Builder setAggregations(
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public Builder mergeAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
+        public Builder mergeAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
           if (aggregationsBuilder_ == null) {
             if (((bitField0_ & 0x00000002) != 0) &&
               aggregations_ != null &&
-              aggregations_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) {
+              aggregations_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) {
               getAggregationsBuilder().mergeFrom(value);
             } else {
               aggregations_ = value;
@@ -23493,7 +23493,7 @@ public Builder clearAggregations() {
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder getAggregationsBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder getAggregationsBuilder() {
           bitField0_ |= 0x00000002;
           onChanged();
           return getAggregationsFieldBuilder().getBuilder();
@@ -23501,23 +23501,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
           if (aggregationsBuilder_ != null) {
             return aggregationsBuilder_.getMessageOrBuilder();
           } else {
             return aggregations_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
           }
         }
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> 
             getAggregationsFieldBuilder() {
           if (aggregationsBuilder_ == null) {
             aggregationsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder>(
                     getAggregations(),
                     getParentForChildren(),
                     isClean());
@@ -23542,12 +23542,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Single)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -23583,7 +23583,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -23613,11 +23613,11 @@ public interface GroupOrBuilder extends
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        * @return The aggregations.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations();
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder();
 
       /**
        * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
@@ -23628,11 +23628,11 @@ public interface GroupOrBuilder extends
        * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
        * @return The groupedBy.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy();
       /**
        * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder();
     }
     /**
      * Protobuf type {@code weaviate.v1.AggregateReply.Group}
@@ -23658,15 +23658,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder.class);
       }
 
       public interface GroupedByOrBuilder extends
@@ -23773,11 +23773,11 @@ public interface GroupedByOrBuilder extends
          * .weaviate.v1.TextArray texts = 6;
          * @return The texts.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getTexts();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getTexts();
         /**
          * .weaviate.v1.TextArray texts = 6;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder();
 
         /**
          * .weaviate.v1.IntArray ints = 7;
@@ -23788,11 +23788,11 @@ public interface GroupedByOrBuilder extends
          * .weaviate.v1.IntArray ints = 7;
          * @return The ints.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getInts();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getInts();
         /**
          * .weaviate.v1.IntArray ints = 7;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder();
 
         /**
          * .weaviate.v1.BooleanArray booleans = 8;
@@ -23803,11 +23803,11 @@ public interface GroupedByOrBuilder extends
          * .weaviate.v1.BooleanArray booleans = 8;
          * @return The booleans.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getBooleans();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getBooleans();
         /**
          * .weaviate.v1.BooleanArray booleans = 8;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder();
 
         /**
          * .weaviate.v1.NumberArray numbers = 9;
@@ -23818,11 +23818,11 @@ public interface GroupedByOrBuilder extends
          * .weaviate.v1.NumberArray numbers = 9;
          * @return The numbers.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getNumbers();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getNumbers();
         /**
          * .weaviate.v1.NumberArray numbers = 9;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder();
 
         /**
          * .weaviate.v1.GeoCoordinatesFilter geo = 10;
@@ -23833,13 +23833,13 @@ public interface GroupedByOrBuilder extends
          * .weaviate.v1.GeoCoordinatesFilter geo = 10;
          * @return The geo.
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getGeo();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getGeo();
         /**
          * .weaviate.v1.GeoCoordinatesFilter geo = 10;
          */
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder();
 
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.ValueCase getValueCase();
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.ValueCase getValueCase();
       }
       /**
        * Protobuf type {@code weaviate.v1.AggregateReply.Group.GroupedBy}
@@ -23867,15 +23867,15 @@ protected java.lang.Object newInstance(
 
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder.class);
         }
 
         private int valueCase_ = 0;
@@ -24116,21 +24116,21 @@ public boolean hasTexts() {
          * @return The texts.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getTexts() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getTexts() {
           if (valueCase_ == 6) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
         }
         /**
          * .weaviate.v1.TextArray texts = 6;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder() {
           if (valueCase_ == 6) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
         }
 
         public static final int INTS_FIELD_NUMBER = 7;
@@ -24147,21 +24147,21 @@ public boolean hasInts() {
          * @return The ints.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getInts() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getInts() {
           if (valueCase_ == 7) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
         }
         /**
          * .weaviate.v1.IntArray ints = 7;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder() {
           if (valueCase_ == 7) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
         }
 
         public static final int BOOLEANS_FIELD_NUMBER = 8;
@@ -24178,21 +24178,21 @@ public boolean hasBooleans() {
          * @return The booleans.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getBooleans() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getBooleans() {
           if (valueCase_ == 8) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
         }
         /**
          * .weaviate.v1.BooleanArray booleans = 8;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder() {
           if (valueCase_ == 8) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
         }
 
         public static final int NUMBERS_FIELD_NUMBER = 9;
@@ -24209,21 +24209,21 @@ public boolean hasNumbers() {
          * @return The numbers.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getNumbers() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getNumbers() {
           if (valueCase_ == 9) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
         }
         /**
          * .weaviate.v1.NumberArray numbers = 9;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder() {
           if (valueCase_ == 9) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
         }
 
         public static final int GEO_FIELD_NUMBER = 10;
@@ -24240,21 +24240,21 @@ public boolean hasGeo() {
          * @return The geo.
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getGeo() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getGeo() {
           if (valueCase_ == 10) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
         }
         /**
          * .weaviate.v1.GeoCoordinatesFilter geo = 10;
          */
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder() {
           if (valueCase_ == 10) {
-             return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_;
+             return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
         }
 
         private byte memoizedIsInitialized = -1;
@@ -24290,19 +24290,19 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
                 5, (double)((java.lang.Double) value_));
           }
           if (valueCase_ == 6) {
-            output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_);
+            output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_);
           }
           if (valueCase_ == 7) {
-            output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_);
+            output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_);
           }
           if (valueCase_ == 8) {
-            output.writeMessage(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_);
+            output.writeMessage(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_);
           }
           if (valueCase_ == 9) {
-            output.writeMessage(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_);
+            output.writeMessage(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_);
           }
           if (valueCase_ == 10) {
-            output.writeMessage(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_);
+            output.writeMessage(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_);
           }
           getUnknownFields().writeTo(output);
         }
@@ -24341,23 +24341,23 @@ public int getSerializedSize() {
           }
           if (valueCase_ == 6) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_);
+              .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_);
           }
           if (valueCase_ == 7) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_);
+              .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_);
           }
           if (valueCase_ == 8) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_);
+              .computeMessageSize(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_);
           }
           if (valueCase_ == 9) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_);
+              .computeMessageSize(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_);
           }
           if (valueCase_ == 10) {
             size += com.google.protobuf.CodedOutputStream
-              .computeMessageSize(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_);
+              .computeMessageSize(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_);
           }
           size += getUnknownFields().getSerializedSize();
           memoizedSize = size;
@@ -24369,10 +24369,10 @@ public boolean equals(final java.lang.Object obj) {
           if (obj == this) {
            return true;
           }
-          if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy)) {
+          if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy)) {
             return super.equals(obj);
           }
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy) obj;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy) obj;
 
           if (!getPathList()
               .equals(other.getPathList())) return false;
@@ -24481,44 +24481,44 @@ public int hashCode() {
           return hash;
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             java.nio.ByteBuffer data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             java.nio.ByteBuffer data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             com.google.protobuf.ByteString data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             com.google.protobuf.ByteString data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(byte[] data)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(byte[] data)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             byte[] data,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws com.google.protobuf.InvalidProtocolBufferException {
           return PARSER.parseFrom(data, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -24526,26 +24526,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
               .parseWithIOException(PARSER, input, extensionRegistry);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseDelimitedFrom(java.io.InputStream input)
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseDelimitedFrom(java.io.InputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input);
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseDelimitedFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseDelimitedFrom(
             java.io.InputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             com.google.protobuf.CodedInputStream input)
             throws java.io.IOException {
           return com.google.protobuf.GeneratedMessageV3
               .parseWithIOException(PARSER, input);
         }
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy parseFrom(
             com.google.protobuf.CodedInputStream input,
             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
             throws java.io.IOException {
@@ -24558,7 +24558,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
         public static Builder newBuilder() {
           return DEFAULT_INSTANCE.toBuilder();
         }
-        public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy prototype) {
+        public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy prototype) {
           return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
         }
         @java.lang.Override
@@ -24579,21 +24579,21 @@ protected Builder newBuilderForType(
         public static final class Builder extends
             com.google.protobuf.GeneratedMessageV3.Builder implements
             // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Group.GroupedBy)
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder {
           public static final com.google.protobuf.Descriptors.Descriptor
               getDescriptor() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
           }
 
           @java.lang.Override
           protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
               internalGetFieldAccessorTable() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_fieldAccessorTable
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_fieldAccessorTable
                 .ensureFieldAccessorsInitialized(
-                    io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder.class);
+                    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder.class);
           }
 
-          // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.newBuilder()
+          // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.newBuilder()
           private Builder() {
 
           }
@@ -24632,17 +24632,17 @@ public Builder clear() {
           @java.lang.Override
           public com.google.protobuf.Descriptors.Descriptor
               getDescriptorForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_GroupedBy_descriptor;
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstanceForType() {
-            return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstanceForType() {
+            return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance();
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy build() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result = buildPartial();
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy build() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result = buildPartial();
             if (!result.isInitialized()) {
               throw newUninitializedMessageException(result);
             }
@@ -24650,15 +24650,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           }
 
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy buildPartial() {
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy(this);
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy buildPartial() {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy(this);
             if (bitField0_ != 0) { buildPartial0(result); }
             buildPartialOneofs(result);
             onBuilt();
             return result;
           }
 
-          private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result) {
+          private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result) {
             int from_bitField0_ = bitField0_;
             if (((from_bitField0_ & 0x00000001) != 0)) {
               path_.makeImmutable();
@@ -24666,7 +24666,7 @@ private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggr
             }
           }
 
-          private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result) {
+          private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy result) {
             result.valueCase_ = valueCase_;
             result.value_ = this.value_;
             if (valueCase_ == 6 &&
@@ -24725,16 +24725,16 @@ public Builder addRepeatedField(
           }
           @java.lang.Override
           public Builder mergeFrom(com.google.protobuf.Message other) {
-            if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy) {
-              return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy)other);
+            if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy) {
+              return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy)other);
             } else {
               super.mergeFrom(other);
               return this;
             }
           }
 
-          public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy other) {
-            if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance()) return this;
+          public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy other) {
+            if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance()) return this;
             if (!other.path_.isEmpty()) {
               if (path_.isEmpty()) {
                 path_ = other.path_;
@@ -25275,7 +25275,7 @@ public Builder clearNumber() {
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> textsBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> textsBuilder_;
           /**
            * .weaviate.v1.TextArray texts = 6;
            * @return Whether the texts field is set.
@@ -25289,23 +25289,23 @@ public boolean hasTexts() {
            * @return The texts.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getTexts() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getTexts() {
             if (textsBuilder_ == null) {
               if (valueCase_ == 6) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
             } else {
               if (valueCase_ == 6) {
                 return textsBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.TextArray texts = 6;
            */
-          public Builder setTexts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+          public Builder setTexts(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
             if (textsBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -25322,7 +25322,7 @@ public Builder setTexts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Te
            * .weaviate.v1.TextArray texts = 6;
            */
           public Builder setTexts(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
             if (textsBuilder_ == null) {
               value_ = builderForValue.build();
               onChanged();
@@ -25335,11 +25335,11 @@ public Builder setTexts(
           /**
            * .weaviate.v1.TextArray texts = 6;
            */
-          public Builder mergeTexts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+          public Builder mergeTexts(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
             if (textsBuilder_ == null) {
               if (valueCase_ == 6 &&
-                  value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_)
+                  value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_)
                     .mergeFrom(value).buildPartial();
               } else {
                 value_ = value;
@@ -25377,36 +25377,36 @@ public Builder clearTexts() {
           /**
            * .weaviate.v1.TextArray texts = 6;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getTextsBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getTextsBuilder() {
             return getTextsFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.TextArray texts = 6;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getTextsOrBuilder() {
             if ((valueCase_ == 6) && (textsBuilder_ != null)) {
               return textsBuilder_.getMessageOrBuilder();
             } else {
               if (valueCase_ == 6) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.TextArray texts = 6;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
               getTextsFieldBuilder() {
             if (textsBuilder_ == null) {
               if (!(valueCase_ == 6)) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
               }
               textsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) value_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) value_,
                       getParentForChildren(),
                       isClean());
               value_ = null;
@@ -25417,7 +25417,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder> intsBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder> intsBuilder_;
           /**
            * .weaviate.v1.IntArray ints = 7;
            * @return Whether the ints field is set.
@@ -25431,23 +25431,23 @@ public boolean hasInts() {
            * @return The ints.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getInts() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getInts() {
             if (intsBuilder_ == null) {
               if (valueCase_ == 7) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
             } else {
               if (valueCase_ == 7) {
                 return intsBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.IntArray ints = 7;
            */
-          public Builder setInts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray value) {
+          public Builder setInts(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray value) {
             if (intsBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -25464,7 +25464,7 @@ public Builder setInts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Int
            * .weaviate.v1.IntArray ints = 7;
            */
           public Builder setInts(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder builderForValue) {
             if (intsBuilder_ == null) {
               value_ = builderForValue.build();
               onChanged();
@@ -25477,11 +25477,11 @@ public Builder setInts(
           /**
            * .weaviate.v1.IntArray ints = 7;
            */
-          public Builder mergeInts(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray value) {
+          public Builder mergeInts(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray value) {
             if (intsBuilder_ == null) {
               if (valueCase_ == 7 &&
-                  value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance()) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_)
+                  value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance()) {
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_)
                     .mergeFrom(value).buildPartial();
               } else {
                 value_ = value;
@@ -25519,36 +25519,36 @@ public Builder clearInts() {
           /**
            * .weaviate.v1.IntArray ints = 7;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder getIntsBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder getIntsBuilder() {
             return getIntsFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.IntArray ints = 7;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getIntsOrBuilder() {
             if ((valueCase_ == 7) && (intsBuilder_ != null)) {
               return intsBuilder_.getMessageOrBuilder();
             } else {
               if (valueCase_ == 7) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.IntArray ints = 7;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder> 
               getIntsFieldBuilder() {
             if (intsBuilder_ == null) {
               if (!(valueCase_ == 7)) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
               }
               intsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) value_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) value_,
                       getParentForChildren(),
                       isClean());
               value_ = null;
@@ -25559,7 +25559,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder g
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder> booleansBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder> booleansBuilder_;
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            * @return Whether the booleans field is set.
@@ -25573,23 +25573,23 @@ public boolean hasBooleans() {
            * @return The booleans.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getBooleans() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getBooleans() {
             if (booleansBuilder_ == null) {
               if (valueCase_ == 8) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
             } else {
               if (valueCase_ == 8) {
                 return booleansBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            */
-          public Builder setBooleans(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray value) {
+          public Builder setBooleans(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray value) {
             if (booleansBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -25606,7 +25606,7 @@ public Builder setBooleans(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
            * .weaviate.v1.BooleanArray booleans = 8;
            */
           public Builder setBooleans(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder builderForValue) {
             if (booleansBuilder_ == null) {
               value_ = builderForValue.build();
               onChanged();
@@ -25619,11 +25619,11 @@ public Builder setBooleans(
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            */
-          public Builder mergeBooleans(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray value) {
+          public Builder mergeBooleans(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray value) {
             if (booleansBuilder_ == null) {
               if (valueCase_ == 8 &&
-                  value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance()) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_)
+                  value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance()) {
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_)
                     .mergeFrom(value).buildPartial();
               } else {
                 value_ = value;
@@ -25661,36 +25661,36 @@ public Builder clearBooleans() {
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder getBooleansBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder getBooleansBuilder() {
             return getBooleansFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getBooleansOrBuilder() {
             if ((valueCase_ == 8) && (booleansBuilder_ != null)) {
               return booleansBuilder_.getMessageOrBuilder();
             } else {
               if (valueCase_ == 8) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.BooleanArray booleans = 8;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder> 
               getBooleansFieldBuilder() {
             if (booleansBuilder_ == null) {
               if (!(valueCase_ == 8)) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
               }
               booleansBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) value_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) value_,
                       getParentForChildren(),
                       isClean());
               value_ = null;
@@ -25701,7 +25701,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuild
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder> numbersBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder> numbersBuilder_;
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            * @return Whether the numbers field is set.
@@ -25715,23 +25715,23 @@ public boolean hasNumbers() {
            * @return The numbers.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getNumbers() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getNumbers() {
             if (numbersBuilder_ == null) {
               if (valueCase_ == 9) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
             } else {
               if (valueCase_ == 9) {
                 return numbersBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            */
-          public Builder setNumbers(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray value) {
+          public Builder setNumbers(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray value) {
             if (numbersBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -25748,7 +25748,7 @@ public Builder setNumbers(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
            * .weaviate.v1.NumberArray numbers = 9;
            */
           public Builder setNumbers(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder builderForValue) {
             if (numbersBuilder_ == null) {
               value_ = builderForValue.build();
               onChanged();
@@ -25761,11 +25761,11 @@ public Builder setNumbers(
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            */
-          public Builder mergeNumbers(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray value) {
+          public Builder mergeNumbers(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray value) {
             if (numbersBuilder_ == null) {
               if (valueCase_ == 9 &&
-                  value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance()) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_)
+                  value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance()) {
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_)
                     .mergeFrom(value).buildPartial();
               } else {
                 value_ = value;
@@ -25803,36 +25803,36 @@ public Builder clearNumbers() {
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder getNumbersBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder getNumbersBuilder() {
             return getNumbersFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getNumbersOrBuilder() {
             if ((valueCase_ == 9) && (numbersBuilder_ != null)) {
               return numbersBuilder_.getMessageOrBuilder();
             } else {
               if (valueCase_ == 9) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.NumberArray numbers = 9;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder> 
               getNumbersFieldBuilder() {
             if (numbersBuilder_ == null) {
               if (!(valueCase_ == 9)) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
               }
               numbersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) value_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) value_,
                       getParentForChildren(),
                       isClean());
               value_ = null;
@@ -25843,7 +25843,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilde
           }
 
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> geoBuilder_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> geoBuilder_;
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            * @return Whether the geo field is set.
@@ -25857,23 +25857,23 @@ public boolean hasGeo() {
            * @return The geo.
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getGeo() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getGeo() {
             if (geoBuilder_ == null) {
               if (valueCase_ == 10) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
             } else {
               if (valueCase_ == 10) {
                 return geoBuilder_.getMessage();
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
-          public Builder setGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter value) {
+          public Builder setGeo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter value) {
             if (geoBuilder_ == null) {
               if (value == null) {
                 throw new NullPointerException();
@@ -25890,7 +25890,7 @@ public Builder setGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoC
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
           public Builder setGeo(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder builderForValue) {
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder builderForValue) {
             if (geoBuilder_ == null) {
               value_ = builderForValue.build();
               onChanged();
@@ -25903,11 +25903,11 @@ public Builder setGeo(
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
-          public Builder mergeGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter value) {
+          public Builder mergeGeo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter value) {
             if (geoBuilder_ == null) {
               if (valueCase_ == 10 &&
-                  value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_)
+                  value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) {
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_)
                     .mergeFrom(value).buildPartial();
               } else {
                 value_ = value;
@@ -25945,36 +25945,36 @@ public Builder clearGeo() {
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder getGeoBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder getGeoBuilder() {
             return getGeoFieldBuilder().getBuilder();
           }
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
           @java.lang.Override
-          public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder() {
+          public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getGeoOrBuilder() {
             if ((valueCase_ == 10) && (geoBuilder_ != null)) {
               return geoBuilder_.getMessageOrBuilder();
             } else {
               if (valueCase_ == 10) {
-                return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_;
+                return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_;
               }
-              return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+              return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
             }
           }
           /**
            * .weaviate.v1.GeoCoordinatesFilter geo = 10;
            */
           private com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> 
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> 
               getGeoFieldBuilder() {
             if (geoBuilder_ == null) {
               if (!(valueCase_ == 10)) {
-                value_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+                value_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
               }
               geoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder>(
-                      (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) value_,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder>(
+                      (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) value_,
                       getParentForChildren(),
                       isClean());
               value_ = null;
@@ -26000,12 +26000,12 @@ public final Builder mergeUnknownFields(
         }
 
         // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Group.GroupedBy)
-        private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy DEFAULT_INSTANCE;
+        private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy DEFAULT_INSTANCE;
         static {
-          DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy();
+          DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy();
         }
 
-        public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstance() {
+        public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstance() {
           return DEFAULT_INSTANCE;
         }
 
@@ -26041,7 +26041,7 @@ public com.google.protobuf.Parser getParserForType() {
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstanceForType() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getDefaultInstanceForType() {
           return DEFAULT_INSTANCE;
         }
 
@@ -26068,7 +26068,7 @@ public long getObjectsCount() {
       }
 
       public static final int AGGREGATIONS_FIELD_NUMBER = 2;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        * @return Whether the aggregations field is set.
@@ -26082,19 +26082,19 @@ public boolean hasAggregations() {
        * @return The aggregations.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
-        return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
+        return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
       }
       /**
        * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
-        return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
+        return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
       }
 
       public static final int GROUPED_BY_FIELD_NUMBER = 3;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy groupedBy_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy groupedBy_;
       /**
        * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
        * @return Whether the groupedBy field is set.
@@ -26108,15 +26108,15 @@ public boolean hasGroupedBy() {
        * @return The groupedBy.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy() {
-        return groupedBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy() {
+        return groupedBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
       }
       /**
        * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder() {
-        return groupedBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder() {
+        return groupedBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
       }
 
       private byte memoizedIsInitialized = -1;
@@ -26173,10 +26173,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group) obj;
 
         if (hasObjectsCount() != other.hasObjectsCount()) return false;
         if (hasObjectsCount()) {
@@ -26222,44 +26222,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -26267,26 +26267,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -26299,7 +26299,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -26320,21 +26320,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Group)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.newBuilder()
         private Builder() {
           maybeForceBuilderInitialization();
         }
@@ -26372,17 +26372,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Group_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -26390,14 +26390,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -26453,16 +26453,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance()) return this;
           if (other.hasObjectsCount()) {
             setObjectsCount(other.getObjectsCount());
           }
@@ -26574,9 +26574,9 @@ public Builder clearObjectsCount() {
           return this;
         }
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations aggregations_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> aggregationsBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> aggregationsBuilder_;
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          * @return Whether the aggregations field is set.
@@ -26588,9 +26588,9 @@ public boolean hasAggregations() {
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          * @return The aggregations.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations getAggregations() {
           if (aggregationsBuilder_ == null) {
-            return aggregations_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+            return aggregations_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
           } else {
             return aggregationsBuilder_.getMessage();
           }
@@ -26598,7 +26598,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public Builder setAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
+        public Builder setAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
           if (aggregationsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -26615,7 +26615,7 @@ public Builder setAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProto
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
         public Builder setAggregations(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder builderForValue) {
           if (aggregationsBuilder_ == null) {
             aggregations_ = builderForValue.build();
           } else {
@@ -26628,11 +26628,11 @@ public Builder setAggregations(
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public Builder mergeAggregations(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
+        public Builder mergeAggregations(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations value) {
           if (aggregationsBuilder_ == null) {
             if (((bitField0_ & 0x00000002) != 0) &&
               aggregations_ != null &&
-              aggregations_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) {
+              aggregations_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance()) {
               getAggregationsBuilder().mergeFrom(value);
             } else {
               aggregations_ = value;
@@ -26662,7 +26662,7 @@ public Builder clearAggregations() {
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder getAggregationsBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder getAggregationsBuilder() {
           bitField0_ |= 0x00000002;
           onChanged();
           return getAggregationsFieldBuilder().getBuilder();
@@ -26670,23 +26670,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder getAggregationsOrBuilder() {
           if (aggregationsBuilder_ != null) {
             return aggregationsBuilder_.getMessageOrBuilder();
           } else {
             return aggregations_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.getDefaultInstance() : aggregations_;
           }
         }
         /**
          * optional .weaviate.v1.AggregateReply.Aggregations aggregations = 2;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder> 
             getAggregationsFieldBuilder() {
           if (aggregationsBuilder_ == null) {
             aggregationsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Aggregations.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.AggregationsOrBuilder>(
                     getAggregations(),
                     getParentForChildren(),
                     isClean());
@@ -26695,9 +26695,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
           return aggregationsBuilder_;
         }
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy groupedBy_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy groupedBy_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder> groupedByBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder> groupedByBuilder_;
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          * @return Whether the groupedBy field is set.
@@ -26709,9 +26709,9 @@ public boolean hasGroupedBy() {
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          * @return The groupedBy.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy getGroupedBy() {
           if (groupedByBuilder_ == null) {
-            return groupedBy_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
+            return groupedBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
           } else {
             return groupedByBuilder_.getMessage();
           }
@@ -26719,7 +26719,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
-        public Builder setGroupedBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy value) {
+        public Builder setGroupedBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy value) {
           if (groupedByBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -26736,7 +26736,7 @@ public Builder setGroupedBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAgg
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
         public Builder setGroupedBy(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder builderForValue) {
           if (groupedByBuilder_ == null) {
             groupedBy_ = builderForValue.build();
           } else {
@@ -26749,11 +26749,11 @@ public Builder setGroupedBy(
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
-        public Builder mergeGroupedBy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy value) {
+        public Builder mergeGroupedBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy value) {
           if (groupedByBuilder_ == null) {
             if (((bitField0_ & 0x00000004) != 0) &&
               groupedBy_ != null &&
-              groupedBy_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance()) {
+              groupedBy_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance()) {
               getGroupedByBuilder().mergeFrom(value);
             } else {
               groupedBy_ = value;
@@ -26783,7 +26783,7 @@ public Builder clearGroupedBy() {
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder getGroupedByBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder getGroupedByBuilder() {
           bitField0_ |= 0x00000004;
           onChanged();
           return getGroupedByFieldBuilder().getBuilder();
@@ -26791,23 +26791,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder getGroupedByOrBuilder() {
           if (groupedByBuilder_ != null) {
             return groupedByBuilder_.getMessageOrBuilder();
           } else {
             return groupedBy_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.getDefaultInstance() : groupedBy_;
           }
         }
         /**
          * optional .weaviate.v1.AggregateReply.Group.GroupedBy grouped_by = 3;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder> 
             getGroupedByFieldBuilder() {
           if (groupedByBuilder_ == null) {
             groupedByBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.GroupedByOrBuilder>(
                     getGroupedBy(),
                     getParentForChildren(),
                     isClean());
@@ -26832,12 +26832,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Group)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -26873,7 +26873,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -26886,12 +26886,12 @@ public interface GroupedOrBuilder extends
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
-      java.util.List 
+      java.util.List 
           getGroupsList();
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index);
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index);
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
@@ -26899,12 +26899,12 @@ public interface GroupedOrBuilder extends
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
-      java.util.List 
+      java.util.List 
           getGroupsOrBuilderList();
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
           int index);
     }
     /**
@@ -26932,32 +26932,32 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder.class);
       }
 
       public static final int GROUPS_FIELD_NUMBER = 1;
       @SuppressWarnings("serial")
-      private java.util.List groups_;
+      private java.util.List groups_;
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
       @java.lang.Override
-      public java.util.List getGroupsList() {
+      public java.util.List getGroupsList() {
         return groups_;
       }
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
       @java.lang.Override
-      public java.util.List 
+      public java.util.List 
           getGroupsOrBuilderList() {
         return groups_;
       }
@@ -26972,14 +26972,14 @@ public int getGroupsCount() {
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index) {
         return groups_.get(index);
       }
       /**
        * repeated .weaviate.v1.AggregateReply.Group groups = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
           int index) {
         return groups_.get(index);
       }
@@ -27024,10 +27024,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) obj;
 
         if (!getGroupsList()
             .equals(other.getGroupsList())) return false;
@@ -27051,44 +27051,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -27096,26 +27096,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -27128,7 +27128,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -27149,21 +27149,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply.Grouped)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.newBuilder()
         private Builder() {
 
         }
@@ -27190,17 +27190,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_Grouped_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -27208,15 +27208,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped(this);
           buildPartialRepeatedFields(result);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped result) {
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped result) {
           if (groupsBuilder_ == null) {
             if (((bitField0_ & 0x00000001) != 0)) {
               groups_ = java.util.Collections.unmodifiableList(groups_);
@@ -27228,7 +27228,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
           }
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped result) {
           int from_bitField0_ = bitField0_;
         }
 
@@ -27266,16 +27266,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance()) return this;
           if (groupsBuilder_ == null) {
             if (!other.groups_.isEmpty()) {
               if (groups_.isEmpty()) {
@@ -27329,9 +27329,9 @@ public Builder mergeFrom(
                   done = true;
                   break;
                 case 10: {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group m =
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group m =
                       input.readMessage(
-                          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.parser(),
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.parser(),
                           extensionRegistry);
                   if (groupsBuilder_ == null) {
                     ensureGroupsIsMutable();
@@ -27358,22 +27358,22 @@ public Builder mergeFrom(
         }
         private int bitField0_;
 
-        private java.util.List groups_ =
+        private java.util.List groups_ =
           java.util.Collections.emptyList();
         private void ensureGroupsIsMutable() {
           if (!((bitField0_ & 0x00000001) != 0)) {
-            groups_ = new java.util.ArrayList(groups_);
+            groups_ = new java.util.ArrayList(groups_);
             bitField0_ |= 0x00000001;
            }
         }
 
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder> groupsBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder> groupsBuilder_;
 
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public java.util.List getGroupsList() {
+        public java.util.List getGroupsList() {
           if (groupsBuilder_ == null) {
             return java.util.Collections.unmodifiableList(groups_);
           } else {
@@ -27393,7 +27393,7 @@ public int getGroupsCount() {
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index) {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group getGroups(int index) {
           if (groupsBuilder_ == null) {
             return groups_.get(index);
           } else {
@@ -27404,7 +27404,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder setGroups(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group value) {
           if (groupsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -27421,7 +27421,7 @@ public Builder setGroups(
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder setGroups(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
           if (groupsBuilder_ == null) {
             ensureGroupsIsMutable();
             groups_.set(index, builderForValue.build());
@@ -27434,7 +27434,7 @@ public Builder setGroups(
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public Builder addGroups(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group value) {
+        public Builder addGroups(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group value) {
           if (groupsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -27451,7 +27451,7 @@ public Builder addGroups(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggreg
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder addGroups(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group value) {
           if (groupsBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -27468,7 +27468,7 @@ public Builder addGroups(
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder addGroups(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
           if (groupsBuilder_ == null) {
             ensureGroupsIsMutable();
             groups_.add(builderForValue.build());
@@ -27482,7 +27482,7 @@ public Builder addGroups(
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder addGroups(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder builderForValue) {
           if (groupsBuilder_ == null) {
             ensureGroupsIsMutable();
             groups_.add(index, builderForValue.build());
@@ -27496,7 +27496,7 @@ public Builder addGroups(
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
         public Builder addAllGroups(
-            java.lang.Iterable values) {
+            java.lang.Iterable values) {
           if (groupsBuilder_ == null) {
             ensureGroupsIsMutable();
             com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -27536,14 +27536,14 @@ public Builder removeGroups(int index) {
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder getGroupsBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder getGroupsBuilder(
             int index) {
           return getGroupsFieldBuilder().getBuilder(index);
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder getGroupsOrBuilder(
             int index) {
           if (groupsBuilder_ == null) {
             return groups_.get(index);  } else {
@@ -27553,7 +27553,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public java.util.List 
+        public java.util.List 
              getGroupsOrBuilderList() {
           if (groupsBuilder_ != null) {
             return groupsBuilder_.getMessageOrBuilderList();
@@ -27564,31 +27564,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder addGroupsBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder addGroupsBuilder() {
           return getGroupsFieldBuilder().addBuilder(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance());
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance());
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder addGroupsBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder addGroupsBuilder(
             int index) {
           return getGroupsFieldBuilder().addBuilder(
-              index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance());
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.getDefaultInstance());
         }
         /**
          * repeated .weaviate.v1.AggregateReply.Group groups = 1;
          */
-        public java.util.List 
+        public java.util.List 
              getGroupsBuilderList() {
           return getGroupsFieldBuilder().getBuilderList();
         }
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder> 
             getGroupsFieldBuilder() {
           if (groupsBuilder_ == null) {
             groupsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Group.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupOrBuilder>(
                     groups_,
                     ((bitField0_ & 0x00000001) != 0),
                     getParentForChildren(),
@@ -27614,12 +27614,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply.Grouped)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -27655,7 +27655,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -27728,21 +27728,21 @@ public boolean hasSingleResult() {
      * @return The singleResult.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getSingleResult() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getSingleResult() {
       if (resultCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
     }
     /**
      * .weaviate.v1.AggregateReply.Single single_result = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder() {
       if (resultCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
     }
 
     public static final int GROUPED_RESULTS_FIELD_NUMBER = 3;
@@ -27759,21 +27759,21 @@ public boolean hasGroupedResults() {
      * @return The groupedResults.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults() {
       if (resultCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
     }
     /**
      * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder() {
       if (resultCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
     }
 
     private byte memoizedIsInitialized = -1;
@@ -27794,10 +27794,10 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
         output.writeFloat(1, took_);
       }
       if (resultCase_ == 2) {
-        output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_);
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_);
       }
       if (resultCase_ == 3) {
-        output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_);
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -27814,11 +27814,11 @@ public int getSerializedSize() {
       }
       if (resultCase_ == 2) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_);
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_);
       }
       if (resultCase_ == 3) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_);
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSize = size;
@@ -27830,10 +27830,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply) obj;
 
       if (java.lang.Float.floatToIntBits(getTook())
           != java.lang.Float.floatToIntBits(
@@ -27882,44 +27882,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27927,26 +27927,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27959,7 +27959,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.Aggrega
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -27980,21 +27980,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.AggregateReply)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReplyOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReplyOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.newBuilder()
       private Builder() {
 
       }
@@ -28023,17 +28023,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.internal_static_weaviate_v1_AggregateReply_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -28041,22 +28041,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.took_ = took_;
         }
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply result) {
         result.resultCase_ = resultCase_;
         result.result_ = this.result_;
         if (resultCase_ == 2 &&
@@ -28103,16 +28103,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.getDefaultInstance()) return this;
         if (other.getTook() != 0F) {
           setTook(other.getTook());
         }
@@ -28239,7 +28239,7 @@ public Builder clearTook() {
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder> singleResultBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder> singleResultBuilder_;
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        * @return Whether the singleResult field is set.
@@ -28253,23 +28253,23 @@ public boolean hasSingleResult() {
        * @return The singleResult.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single getSingleResult() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single getSingleResult() {
         if (singleResultBuilder_ == null) {
           if (resultCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
         } else {
           if (resultCase_ == 2) {
             return singleResultBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
-      public Builder setSingleResult(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single value) {
+      public Builder setSingleResult(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single value) {
         if (singleResultBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -28286,7 +28286,7 @@ public Builder setSingleResult(io.weaviate.client.grpc.protocol.v1.WeaviateProto
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
       public Builder setSingleResult(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder builderForValue) {
         if (singleResultBuilder_ == null) {
           result_ = builderForValue.build();
           onChanged();
@@ -28299,11 +28299,11 @@ public Builder setSingleResult(
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
-      public Builder mergeSingleResult(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single value) {
+      public Builder mergeSingleResult(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single value) {
         if (singleResultBuilder_ == null) {
           if (resultCase_ == 2 &&
-              result_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance()) {
-            result_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_)
+              result_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance()) {
+            result_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_)
                 .mergeFrom(value).buildPartial();
           } else {
             result_ = value;
@@ -28341,36 +28341,36 @@ public Builder clearSingleResult() {
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder getSingleResultBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder getSingleResultBuilder() {
         return getSingleResultFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder getSingleResultOrBuilder() {
         if ((resultCase_ == 2) && (singleResultBuilder_ != null)) {
           return singleResultBuilder_.getMessageOrBuilder();
         } else {
           if (resultCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.AggregateReply.Single single_result = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder> 
           getSingleResultFieldBuilder() {
         if (singleResultBuilder_ == null) {
           if (!(resultCase_ == 2)) {
-            result_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
+            result_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.getDefaultInstance();
           }
           singleResultBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Single) result_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.SingleOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Single) result_,
                   getParentForChildren(),
                   isClean());
           result_ = null;
@@ -28381,7 +28381,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder> groupedResultsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder> groupedResultsBuilder_;
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        * @return Whether the groupedResults field is set.
@@ -28395,23 +28395,23 @@ public boolean hasGroupedResults() {
        * @return The groupedResults.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped getGroupedResults() {
         if (groupedResultsBuilder_ == null) {
           if (resultCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
         } else {
           if (resultCase_ == 3) {
             return groupedResultsBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
-      public Builder setGroupedResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped value) {
+      public Builder setGroupedResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped value) {
         if (groupedResultsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -28428,7 +28428,7 @@ public Builder setGroupedResults(io.weaviate.client.grpc.protocol.v1.WeaviatePro
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
       public Builder setGroupedResults(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder builderForValue) {
         if (groupedResultsBuilder_ == null) {
           result_ = builderForValue.build();
           onChanged();
@@ -28441,11 +28441,11 @@ public Builder setGroupedResults(
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
-      public Builder mergeGroupedResults(io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped value) {
+      public Builder mergeGroupedResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped value) {
         if (groupedResultsBuilder_ == null) {
           if (resultCase_ == 3 &&
-              result_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance()) {
-            result_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_)
+              result_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance()) {
+            result_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_)
                 .mergeFrom(value).buildPartial();
           } else {
             result_ = value;
@@ -28483,36 +28483,36 @@ public Builder clearGroupedResults() {
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder getGroupedResultsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder getGroupedResultsBuilder() {
         return getGroupedResultsFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder getGroupedResultsOrBuilder() {
         if ((resultCase_ == 3) && (groupedResultsBuilder_ != null)) {
           return groupedResultsBuilder_.getMessageOrBuilder();
         } else {
           if (resultCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.AggregateReply.Grouped grouped_results = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder> 
           getGroupedResultsFieldBuilder() {
         if (groupedResultsBuilder_ == null) {
           if (!(resultCase_ == 3)) {
-            result_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
+            result_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.getDefaultInstance();
           }
           groupedResultsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply.Grouped) result_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.GroupedOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply.Grouped) result_,
                   getParentForChildren(),
                   isClean());
           result_ = null;
@@ -28538,12 +28538,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.AggregateReply)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28579,7 +28579,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoAggregate.AggregateReply getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28839,16 +28839,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
       "B\007\n\005valueB\020\n\016_objects_countB\017\n\r_aggregat" +
       "ionsB\r\n\013_grouped_by\032<\n\007Grouped\0221\n\006groups" +
       "\030\001 \003(\0132!.weaviate.v1.AggregateReply.Grou" +
-      "pB\010\n\006resultBs\n#io.weaviate.client.grpc.p" +
-      "rotocol.v1B\026WeaviateProtoAggregateZ4gith" +
-      "ub.com/weaviate/weaviate/grpc/generated;" +
-      "protocolb\006proto3"
+      "pB\010\n\006resultBG\n-io.weaviate.client6.v1.in" +
+      "ternal.grpc.protocolB\026WeaviateProtoAggre" +
+      "gateb\006proto3"
     };
     descriptor = com.google.protobuf.Descriptors.FileDescriptor
       .internalBuildGeneratedFileFrom(descriptorData,
         new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(),
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.getDescriptor(),
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(),
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.getDescriptor(),
         });
     internal_static_weaviate_v1_AggregateRequest_descriptor =
       getDescriptor().getMessageTypes().get(0);
@@ -28994,8 +28993,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoAggregate.AggregateReply
       com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
         internal_static_weaviate_v1_AggregateReply_Grouped_descriptor,
         new java.lang.String[] { "Groups", });
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor();
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.getDescriptor();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.getDescriptor();
   }
 
   // @@protoc_insertion_point(outer_class_scope)
diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBase.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBase.java
similarity index 77%
rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBase.java
rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBase.java
index c7bae9570..c0ae534aa 100644
--- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBase.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBase.java
@@ -1,7 +1,7 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: v1/base.proto
 
-package io.weaviate.client.grpc.protocol.v1;
+package io.weaviate.client6.v1.internal.grpc.protocol;
 
 public final class WeaviateProtoBase {
   private WeaviateProtoBase() {}
@@ -114,7 +114,7 @@ public ConsistencyLevel findValueByNumber(int number) {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor().getEnumTypes().get(0);
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor().getEnumTypes().get(0);
     }
 
     private static final ConsistencyLevel[] VALUES = values();
@@ -152,7 +152,7 @@ public interface NumberArrayPropertiesOrBuilder extends
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @return A list containing the values.
      */
     @java.lang.Deprecated java.util.List getValuesList();
@@ -164,7 +164,7 @@ public interface NumberArrayPropertiesOrBuilder extends
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @return The count of values.
      */
     @java.lang.Deprecated int getValuesCount();
@@ -176,7 +176,7 @@ public interface NumberArrayPropertiesOrBuilder extends
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @param index The index of the element to return.
      * @return The values at the given index.
      */
@@ -227,15 +227,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -250,7 +250,7 @@ protected java.lang.Object newInstance(
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @return A list containing the values.
      */
     @java.lang.Override
@@ -266,7 +266,7 @@ protected java.lang.Object newInstance(
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @return The count of values.
      */
     @java.lang.Deprecated public int getValuesCount() {
@@ -280,7 +280,7 @@ protected java.lang.Object newInstance(
      *
      * repeated double values = 1 [deprecated = true];
      * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-     *     See v1/base.proto;l=19
+     *     See v1/base.proto;l=18
      * @param index The index of the element to return.
      * @return The values at the given index.
      */
@@ -404,10 +404,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -439,44 +439,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -484,26 +484,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayP
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -516,7 +516,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayP
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -537,21 +537,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NumberArrayProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.newBuilder()
       private Builder() {
 
       }
@@ -574,17 +574,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArrayProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -592,14 +592,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperti
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -647,16 +647,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -767,7 +767,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @return A list containing the values.
        */
       @java.lang.Deprecated public java.util.List
@@ -783,7 +783,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @return The count of values.
        */
       @java.lang.Deprecated public int getValuesCount() {
@@ -797,7 +797,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @param index The index of the element to return.
        * @return The values at the given index.
        */
@@ -812,7 +812,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @param index The index to set the value at.
        * @param value The values to set.
        * @return This builder for chaining.
@@ -834,7 +834,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @param value The values to add.
        * @return This builder for chaining.
        */
@@ -854,7 +854,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @param values The values to add.
        * @return This builder for chaining.
        */
@@ -875,7 +875,7 @@ private void ensureValuesIsMutable(int capacity) {
        *
        * repeated double values = 1 [deprecated = true];
        * @deprecated weaviate.v1.NumberArrayProperties.values is deprecated.
-       *     See v1/base.proto;l=19
+       *     See v1/base.proto;l=18
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearValues() {
@@ -1005,12 +1005,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NumberArrayProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1046,7 +1046,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1111,15 +1111,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -1252,10 +1252,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -1283,44 +1283,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1328,26 +1328,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProp
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1360,7 +1360,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProp
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -1381,21 +1381,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.IntArrayProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.newBuilder()
       private Builder() {
 
       }
@@ -1417,17 +1417,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArrayProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -1435,14 +1435,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -1487,16 +1487,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -1749,12 +1749,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.IntArrayProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1790,7 +1790,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1864,15 +1864,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -2001,10 +2001,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -2032,44 +2032,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2077,26 +2077,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPro
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2109,7 +2109,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPro
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -2130,21 +2130,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.TextArrayProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.newBuilder()
       private Builder() {
 
       }
@@ -2167,17 +2167,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArrayProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -2185,14 +2185,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -2237,16 +2237,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -2515,12 +2515,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.TextArrayProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -2556,7 +2556,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -2621,15 +2621,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -2759,10 +2759,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -2790,44 +2790,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2835,26 +2835,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2867,7 +2867,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -2888,21 +2888,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.BooleanArrayProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.newBuilder()
       private Builder() {
 
       }
@@ -2924,17 +2924,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArrayProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -2942,14 +2942,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropert
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -2994,16 +2994,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -3263,12 +3263,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.BooleanArrayProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3304,7 +3304,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3332,12 +3332,12 @@ public interface ObjectPropertiesValueOrBuilder extends
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
-    java.util.List 
+    java.util.List 
         getNumberArrayPropertiesList();
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index);
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
@@ -3345,23 +3345,23 @@ public interface ObjectPropertiesValueOrBuilder extends
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
-    java.util.List 
+    java.util.List 
         getNumberArrayPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
-    java.util.List 
+    java.util.List 
         getIntArrayPropertiesList();
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index);
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
@@ -3369,23 +3369,23 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBui
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
-    java.util.List 
+    java.util.List 
         getIntArrayPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
-    java.util.List 
+    java.util.List 
         getTextArrayPropertiesList();
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index);
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
@@ -3393,23 +3393,23 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilde
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
-    java.util.List 
+    java.util.List 
         getTextArrayPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
-    java.util.List 
+    java.util.List 
         getBooleanArrayPropertiesList();
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index);
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
@@ -3417,23 +3417,23 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuild
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
-    java.util.List 
+    java.util.List 
         getBooleanArrayPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
-    java.util.List 
+    java.util.List 
         getObjectPropertiesList();
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index);
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
@@ -3441,23 +3441,23 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBu
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
-    java.util.List 
+    java.util.List 
         getObjectPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
-    java.util.List 
+    java.util.List 
         getObjectArrayPropertiesList();
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index);
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
@@ -3465,12 +3465,12 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
-    java.util.List 
+    java.util.List 
         getObjectArrayPropertiesOrBuilderList();
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
         int index);
 
     /**
@@ -3530,15 +3530,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder.class);
     }
 
     private int bitField0_;
@@ -3570,19 +3570,19 @@ public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() {
 
     public static final int NUMBER_ARRAY_PROPERTIES_FIELD_NUMBER = 2;
     @SuppressWarnings("serial")
-    private java.util.List numberArrayProperties_;
+    private java.util.List numberArrayProperties_;
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
     @java.lang.Override
-    public java.util.List getNumberArrayPropertiesList() {
+    public java.util.List getNumberArrayPropertiesList() {
       return numberArrayProperties_;
     }
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getNumberArrayPropertiesOrBuilderList() {
       return numberArrayProperties_;
     }
@@ -3597,33 +3597,33 @@ public int getNumberArrayPropertiesCount() {
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) {
       return numberArrayProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
         int index) {
       return numberArrayProperties_.get(index);
     }
 
     public static final int INT_ARRAY_PROPERTIES_FIELD_NUMBER = 3;
     @SuppressWarnings("serial")
-    private java.util.List intArrayProperties_;
+    private java.util.List intArrayProperties_;
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
     @java.lang.Override
-    public java.util.List getIntArrayPropertiesList() {
+    public java.util.List getIntArrayPropertiesList() {
       return intArrayProperties_;
     }
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getIntArrayPropertiesOrBuilderList() {
       return intArrayProperties_;
     }
@@ -3638,33 +3638,33 @@ public int getIntArrayPropertiesCount() {
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) {
       return intArrayProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
         int index) {
       return intArrayProperties_.get(index);
     }
 
     public static final int TEXT_ARRAY_PROPERTIES_FIELD_NUMBER = 4;
     @SuppressWarnings("serial")
-    private java.util.List textArrayProperties_;
+    private java.util.List textArrayProperties_;
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
     @java.lang.Override
-    public java.util.List getTextArrayPropertiesList() {
+    public java.util.List getTextArrayPropertiesList() {
       return textArrayProperties_;
     }
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getTextArrayPropertiesOrBuilderList() {
       return textArrayProperties_;
     }
@@ -3679,33 +3679,33 @@ public int getTextArrayPropertiesCount() {
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) {
       return textArrayProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
         int index) {
       return textArrayProperties_.get(index);
     }
 
     public static final int BOOLEAN_ARRAY_PROPERTIES_FIELD_NUMBER = 5;
     @SuppressWarnings("serial")
-    private java.util.List booleanArrayProperties_;
+    private java.util.List booleanArrayProperties_;
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
     @java.lang.Override
-    public java.util.List getBooleanArrayPropertiesList() {
+    public java.util.List getBooleanArrayPropertiesList() {
       return booleanArrayProperties_;
     }
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getBooleanArrayPropertiesOrBuilderList() {
       return booleanArrayProperties_;
     }
@@ -3720,33 +3720,33 @@ public int getBooleanArrayPropertiesCount() {
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) {
       return booleanArrayProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
         int index) {
       return booleanArrayProperties_.get(index);
     }
 
     public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 6;
     @SuppressWarnings("serial")
-    private java.util.List objectProperties_;
+    private java.util.List objectProperties_;
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
     @java.lang.Override
-    public java.util.List getObjectPropertiesList() {
+    public java.util.List getObjectPropertiesList() {
       return objectProperties_;
     }
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getObjectPropertiesOrBuilderList() {
       return objectProperties_;
     }
@@ -3761,33 +3761,33 @@ public int getObjectPropertiesCount() {
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) {
       return objectProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.ObjectProperties object_properties = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
         int index) {
       return objectProperties_.get(index);
     }
 
     public static final int OBJECT_ARRAY_PROPERTIES_FIELD_NUMBER = 7;
     @SuppressWarnings("serial")
-    private java.util.List objectArrayProperties_;
+    private java.util.List objectArrayProperties_;
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
     @java.lang.Override
-    public java.util.List getObjectArrayPropertiesList() {
+    public java.util.List getObjectArrayPropertiesList() {
       return objectArrayProperties_;
     }
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getObjectArrayPropertiesOrBuilderList() {
       return objectArrayProperties_;
     }
@@ -3802,14 +3802,14 @@ public int getObjectArrayPropertiesCount() {
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) {
       return objectArrayProperties_.get(index);
     }
     /**
      * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
         int index) {
       return objectArrayProperties_.get(index);
     }
@@ -3944,10 +3944,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue) obj;
 
       if (hasNonRefProperties() != other.hasNonRefProperties()) return false;
       if (hasNonRefProperties()) {
@@ -4016,44 +4016,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4061,26 +4061,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProper
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4093,7 +4093,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProper
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -4114,21 +4114,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectPropertiesValue)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -4209,17 +4209,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectPropertiesValue_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -4227,15 +4227,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue result) {
         if (numberArrayPropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0)) {
             numberArrayProperties_ = java.util.Collections.unmodifiableList(numberArrayProperties_);
@@ -4292,7 +4292,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -4342,16 +4342,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance()) return this;
         if (other.hasNonRefProperties()) {
           mergeNonRefProperties(other.getNonRefProperties());
         }
@@ -4555,9 +4555,9 @@ public Builder mergeFrom(
                 break;
               } // case 10
               case 18: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.parser(),
                         extensionRegistry);
                 if (numberArrayPropertiesBuilder_ == null) {
                   ensureNumberArrayPropertiesIsMutable();
@@ -4568,9 +4568,9 @@ public Builder mergeFrom(
                 break;
               } // case 18
               case 26: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.parser(),
                         extensionRegistry);
                 if (intArrayPropertiesBuilder_ == null) {
                   ensureIntArrayPropertiesIsMutable();
@@ -4581,9 +4581,9 @@ public Builder mergeFrom(
                 break;
               } // case 26
               case 34: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.parser(),
                         extensionRegistry);
                 if (textArrayPropertiesBuilder_ == null) {
                   ensureTextArrayPropertiesIsMutable();
@@ -4594,9 +4594,9 @@ public Builder mergeFrom(
                 break;
               } // case 34
               case 42: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.parser(),
                         extensionRegistry);
                 if (booleanArrayPropertiesBuilder_ == null) {
                   ensureBooleanArrayPropertiesIsMutable();
@@ -4607,9 +4607,9 @@ public Builder mergeFrom(
                 break;
               } // case 42
               case 50: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.parser(),
                         extensionRegistry);
                 if (objectPropertiesBuilder_ == null) {
                   ensureObjectPropertiesIsMutable();
@@ -4620,9 +4620,9 @@ public Builder mergeFrom(
                 break;
               } // case 50
               case 58: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.parser(),
                         extensionRegistry);
                 if (objectArrayPropertiesBuilder_ == null) {
                   ensureObjectArrayPropertiesIsMutable();
@@ -4776,22 +4776,22 @@ public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() {
         return nonRefPropertiesBuilder_;
       }
 
-      private java.util.List numberArrayProperties_ =
+      private java.util.List numberArrayProperties_ =
         java.util.Collections.emptyList();
       private void ensureNumberArrayPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000002) != 0)) {
-          numberArrayProperties_ = new java.util.ArrayList(numberArrayProperties_);
+          numberArrayProperties_ = new java.util.ArrayList(numberArrayProperties_);
           bitField0_ |= 0x00000002;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> numberArrayPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> numberArrayPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public java.util.List getNumberArrayPropertiesList() {
+      public java.util.List getNumberArrayPropertiesList() {
         if (numberArrayPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(numberArrayProperties_);
         } else {
@@ -4811,7 +4811,7 @@ public int getNumberArrayPropertiesCount() {
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) {
         if (numberArrayPropertiesBuilder_ == null) {
           return numberArrayProperties_.get(index);
         } else {
@@ -4822,7 +4822,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperti
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder setNumberArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) {
         if (numberArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4839,7 +4839,7 @@ public Builder setNumberArrayProperties(
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder setNumberArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
         if (numberArrayPropertiesBuilder_ == null) {
           ensureNumberArrayPropertiesIsMutable();
           numberArrayProperties_.set(index, builderForValue.build());
@@ -4852,7 +4852,7 @@ public Builder setNumberArrayProperties(
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public Builder addNumberArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) {
+      public Builder addNumberArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) {
         if (numberArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4869,7 +4869,7 @@ public Builder addNumberArrayProperties(io.weaviate.client.grpc.protocol.v1.Weav
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder addNumberArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) {
         if (numberArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -4886,7 +4886,7 @@ public Builder addNumberArrayProperties(
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder addNumberArrayProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
         if (numberArrayPropertiesBuilder_ == null) {
           ensureNumberArrayPropertiesIsMutable();
           numberArrayProperties_.add(builderForValue.build());
@@ -4900,7 +4900,7 @@ public Builder addNumberArrayProperties(
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder addNumberArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) {
         if (numberArrayPropertiesBuilder_ == null) {
           ensureNumberArrayPropertiesIsMutable();
           numberArrayProperties_.add(index, builderForValue.build());
@@ -4914,7 +4914,7 @@ public Builder addNumberArrayProperties(
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
       public Builder addAllNumberArrayProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (numberArrayPropertiesBuilder_ == null) {
           ensureNumberArrayPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -4954,14 +4954,14 @@ public Builder removeNumberArrayProperties(int index) {
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder getNumberArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder getNumberArrayPropertiesBuilder(
           int index) {
         return getNumberArrayPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder(
           int index) {
         if (numberArrayPropertiesBuilder_ == null) {
           return numberArrayProperties_.get(index);  } else {
@@ -4971,7 +4971,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperti
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public java.util.List 
+      public java.util.List 
            getNumberArrayPropertiesOrBuilderList() {
         if (numberArrayPropertiesBuilder_ != null) {
           return numberArrayPropertiesBuilder_.getMessageOrBuilderList();
@@ -4982,31 +4982,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperti
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder() {
         return getNumberArrayPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder(
           int index) {
         return getNumberArrayPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 2;
        */
-      public java.util.List 
+      public java.util.List 
            getNumberArrayPropertiesBuilderList() {
         return getNumberArrayPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> 
           getNumberArrayPropertiesFieldBuilder() {
         if (numberArrayPropertiesBuilder_ == null) {
           numberArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder>(
                   numberArrayProperties_,
                   ((bitField0_ & 0x00000002) != 0),
                   getParentForChildren(),
@@ -5016,22 +5016,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayProperti
         return numberArrayPropertiesBuilder_;
       }
 
-      private java.util.List intArrayProperties_ =
+      private java.util.List intArrayProperties_ =
         java.util.Collections.emptyList();
       private void ensureIntArrayPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000004) != 0)) {
-          intArrayProperties_ = new java.util.ArrayList(intArrayProperties_);
+          intArrayProperties_ = new java.util.ArrayList(intArrayProperties_);
           bitField0_ |= 0x00000004;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder> intArrayPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder> intArrayPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public java.util.List getIntArrayPropertiesList() {
+      public java.util.List getIntArrayPropertiesList() {
         if (intArrayPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(intArrayProperties_);
         } else {
@@ -5051,7 +5051,7 @@ public int getIntArrayPropertiesCount() {
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) {
         if (intArrayPropertiesBuilder_ == null) {
           return intArrayProperties_.get(index);
         } else {
@@ -5062,7 +5062,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder setIntArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) {
         if (intArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5079,7 +5079,7 @@ public Builder setIntArrayProperties(
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder setIntArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
         if (intArrayPropertiesBuilder_ == null) {
           ensureIntArrayPropertiesIsMutable();
           intArrayProperties_.set(index, builderForValue.build());
@@ -5092,7 +5092,7 @@ public Builder setIntArrayProperties(
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public Builder addIntArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) {
+      public Builder addIntArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) {
         if (intArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5109,7 +5109,7 @@ public Builder addIntArrayProperties(io.weaviate.client.grpc.protocol.v1.Weaviat
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder addIntArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) {
         if (intArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5126,7 +5126,7 @@ public Builder addIntArrayProperties(
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder addIntArrayProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
         if (intArrayPropertiesBuilder_ == null) {
           ensureIntArrayPropertiesIsMutable();
           intArrayProperties_.add(builderForValue.build());
@@ -5140,7 +5140,7 @@ public Builder addIntArrayProperties(
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder addIntArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) {
         if (intArrayPropertiesBuilder_ == null) {
           ensureIntArrayPropertiesIsMutable();
           intArrayProperties_.add(index, builderForValue.build());
@@ -5154,7 +5154,7 @@ public Builder addIntArrayProperties(
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
       public Builder addAllIntArrayProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (intArrayPropertiesBuilder_ == null) {
           ensureIntArrayPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -5194,14 +5194,14 @@ public Builder removeIntArrayProperties(int index) {
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder getIntArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder getIntArrayPropertiesBuilder(
           int index) {
         return getIntArrayPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder(
           int index) {
         if (intArrayPropertiesBuilder_ == null) {
           return intArrayProperties_.get(index);  } else {
@@ -5211,7 +5211,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesO
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getIntArrayPropertiesOrBuilderList() {
         if (intArrayPropertiesBuilder_ != null) {
           return intArrayPropertiesBuilder_.getMessageOrBuilderList();
@@ -5222,31 +5222,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesO
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder() {
         return getIntArrayPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder(
           int index) {
         return getIntArrayPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.IntArrayProperties int_array_properties = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getIntArrayPropertiesBuilderList() {
         return getIntArrayPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder> 
           getIntArrayPropertiesFieldBuilder() {
         if (intArrayPropertiesBuilder_ == null) {
           intArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder>(
                   intArrayProperties_,
                   ((bitField0_ & 0x00000004) != 0),
                   getParentForChildren(),
@@ -5256,22 +5256,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayProperties.
         return intArrayPropertiesBuilder_;
       }
 
-      private java.util.List textArrayProperties_ =
+      private java.util.List textArrayProperties_ =
         java.util.Collections.emptyList();
       private void ensureTextArrayPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000008) != 0)) {
-          textArrayProperties_ = new java.util.ArrayList(textArrayProperties_);
+          textArrayProperties_ = new java.util.ArrayList(textArrayProperties_);
           bitField0_ |= 0x00000008;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder> textArrayPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder> textArrayPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public java.util.List getTextArrayPropertiesList() {
+      public java.util.List getTextArrayPropertiesList() {
         if (textArrayPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(textArrayProperties_);
         } else {
@@ -5291,7 +5291,7 @@ public int getTextArrayPropertiesCount() {
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) {
         if (textArrayPropertiesBuilder_ == null) {
           return textArrayProperties_.get(index);
         } else {
@@ -5302,7 +5302,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder setTextArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) {
         if (textArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5319,7 +5319,7 @@ public Builder setTextArrayProperties(
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder setTextArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
         if (textArrayPropertiesBuilder_ == null) {
           ensureTextArrayPropertiesIsMutable();
           textArrayProperties_.set(index, builderForValue.build());
@@ -5332,7 +5332,7 @@ public Builder setTextArrayProperties(
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public Builder addTextArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) {
+      public Builder addTextArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) {
         if (textArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5349,7 +5349,7 @@ public Builder addTextArrayProperties(io.weaviate.client.grpc.protocol.v1.Weavia
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder addTextArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) {
         if (textArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5366,7 +5366,7 @@ public Builder addTextArrayProperties(
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder addTextArrayProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
         if (textArrayPropertiesBuilder_ == null) {
           ensureTextArrayPropertiesIsMutable();
           textArrayProperties_.add(builderForValue.build());
@@ -5380,7 +5380,7 @@ public Builder addTextArrayProperties(
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder addTextArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) {
         if (textArrayPropertiesBuilder_ == null) {
           ensureTextArrayPropertiesIsMutable();
           textArrayProperties_.add(index, builderForValue.build());
@@ -5394,7 +5394,7 @@ public Builder addTextArrayProperties(
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
       public Builder addAllTextArrayProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (textArrayPropertiesBuilder_ == null) {
           ensureTextArrayPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -5434,14 +5434,14 @@ public Builder removeTextArrayProperties(int index) {
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder getTextArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder getTextArrayPropertiesBuilder(
           int index) {
         return getTextArrayPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder(
           int index) {
         if (textArrayPropertiesBuilder_ == null) {
           return textArrayProperties_.get(index);  } else {
@@ -5451,7 +5451,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public java.util.List 
+      public java.util.List 
            getTextArrayPropertiesOrBuilderList() {
         if (textArrayPropertiesBuilder_ != null) {
           return textArrayPropertiesBuilder_.getMessageOrBuilderList();
@@ -5462,31 +5462,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder() {
         return getTextArrayPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder(
           int index) {
         return getTextArrayPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.TextArrayProperties text_array_properties = 4;
        */
-      public java.util.List 
+      public java.util.List 
            getTextArrayPropertiesBuilderList() {
         return getTextArrayPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder> 
           getTextArrayPropertiesFieldBuilder() {
         if (textArrayPropertiesBuilder_ == null) {
           textArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder>(
                   textArrayProperties_,
                   ((bitField0_ & 0x00000008) != 0),
                   getParentForChildren(),
@@ -5496,22 +5496,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayProperties
         return textArrayPropertiesBuilder_;
       }
 
-      private java.util.List booleanArrayProperties_ =
+      private java.util.List booleanArrayProperties_ =
         java.util.Collections.emptyList();
       private void ensureBooleanArrayPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000010) != 0)) {
-          booleanArrayProperties_ = new java.util.ArrayList(booleanArrayProperties_);
+          booleanArrayProperties_ = new java.util.ArrayList(booleanArrayProperties_);
           bitField0_ |= 0x00000010;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> booleanArrayPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> booleanArrayPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public java.util.List getBooleanArrayPropertiesList() {
+      public java.util.List getBooleanArrayPropertiesList() {
         if (booleanArrayPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(booleanArrayProperties_);
         } else {
@@ -5531,7 +5531,7 @@ public int getBooleanArrayPropertiesCount() {
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) {
         if (booleanArrayPropertiesBuilder_ == null) {
           return booleanArrayProperties_.get(index);
         } else {
@@ -5542,7 +5542,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropert
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder setBooleanArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) {
         if (booleanArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5559,7 +5559,7 @@ public Builder setBooleanArrayProperties(
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder setBooleanArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
         if (booleanArrayPropertiesBuilder_ == null) {
           ensureBooleanArrayPropertiesIsMutable();
           booleanArrayProperties_.set(index, builderForValue.build());
@@ -5572,7 +5572,7 @@ public Builder setBooleanArrayProperties(
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public Builder addBooleanArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) {
+      public Builder addBooleanArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) {
         if (booleanArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5589,7 +5589,7 @@ public Builder addBooleanArrayProperties(io.weaviate.client.grpc.protocol.v1.Wea
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder addBooleanArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) {
         if (booleanArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5606,7 +5606,7 @@ public Builder addBooleanArrayProperties(
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder addBooleanArrayProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
         if (booleanArrayPropertiesBuilder_ == null) {
           ensureBooleanArrayPropertiesIsMutable();
           booleanArrayProperties_.add(builderForValue.build());
@@ -5620,7 +5620,7 @@ public Builder addBooleanArrayProperties(
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder addBooleanArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) {
         if (booleanArrayPropertiesBuilder_ == null) {
           ensureBooleanArrayPropertiesIsMutable();
           booleanArrayProperties_.add(index, builderForValue.build());
@@ -5634,7 +5634,7 @@ public Builder addBooleanArrayProperties(
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
       public Builder addAllBooleanArrayProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (booleanArrayPropertiesBuilder_ == null) {
           ensureBooleanArrayPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -5674,14 +5674,14 @@ public Builder removeBooleanArrayProperties(int index) {
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder getBooleanArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder getBooleanArrayPropertiesBuilder(
           int index) {
         return getBooleanArrayPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder(
           int index) {
         if (booleanArrayPropertiesBuilder_ == null) {
           return booleanArrayProperties_.get(index);  } else {
@@ -5691,7 +5691,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropert
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public java.util.List 
+      public java.util.List 
            getBooleanArrayPropertiesOrBuilderList() {
         if (booleanArrayPropertiesBuilder_ != null) {
           return booleanArrayPropertiesBuilder_.getMessageOrBuilderList();
@@ -5702,31 +5702,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropert
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder() {
         return getBooleanArrayPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder(
           int index) {
         return getBooleanArrayPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 5;
        */
-      public java.util.List 
+      public java.util.List 
            getBooleanArrayPropertiesBuilderList() {
         return getBooleanArrayPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> 
           getBooleanArrayPropertiesFieldBuilder() {
         if (booleanArrayPropertiesBuilder_ == null) {
           booleanArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder>(
                   booleanArrayProperties_,
                   ((bitField0_ & 0x00000010) != 0),
                   getParentForChildren(),
@@ -5736,22 +5736,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayPropert
         return booleanArrayPropertiesBuilder_;
       }
 
-      private java.util.List objectProperties_ =
+      private java.util.List objectProperties_ =
         java.util.Collections.emptyList();
       private void ensureObjectPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000020) != 0)) {
-          objectProperties_ = new java.util.ArrayList(objectProperties_);
+          objectProperties_ = new java.util.ArrayList(objectProperties_);
           bitField0_ |= 0x00000020;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder> objectPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder> objectPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public java.util.List getObjectPropertiesList() {
+      public java.util.List getObjectPropertiesList() {
         if (objectPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(objectProperties_);
         } else {
@@ -5771,7 +5771,7 @@ public int getObjectPropertiesCount() {
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) {
         if (objectPropertiesBuilder_ == null) {
           return objectProperties_.get(index);
         } else {
@@ -5782,7 +5782,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties ge
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder setObjectProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) {
         if (objectPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5799,7 +5799,7 @@ public Builder setObjectProperties(
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder setObjectProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
         if (objectPropertiesBuilder_ == null) {
           ensureObjectPropertiesIsMutable();
           objectProperties_.set(index, builderForValue.build());
@@ -5812,7 +5812,7 @@ public Builder setObjectProperties(
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public Builder addObjectProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) {
+      public Builder addObjectProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) {
         if (objectPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5829,7 +5829,7 @@ public Builder addObjectProperties(io.weaviate.client.grpc.protocol.v1.WeaviateP
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder addObjectProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) {
         if (objectPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5846,7 +5846,7 @@ public Builder addObjectProperties(
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder addObjectProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
         if (objectPropertiesBuilder_ == null) {
           ensureObjectPropertiesIsMutable();
           objectProperties_.add(builderForValue.build());
@@ -5860,7 +5860,7 @@ public Builder addObjectProperties(
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder addObjectProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) {
         if (objectPropertiesBuilder_ == null) {
           ensureObjectPropertiesIsMutable();
           objectProperties_.add(index, builderForValue.build());
@@ -5874,7 +5874,7 @@ public Builder addObjectProperties(
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
       public Builder addAllObjectProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (objectPropertiesBuilder_ == null) {
           ensureObjectPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -5914,14 +5914,14 @@ public Builder removeObjectProperties(int index) {
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder getObjectPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder getObjectPropertiesBuilder(
           int index) {
         return getObjectPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder(
           int index) {
         if (objectPropertiesBuilder_ == null) {
           return objectProperties_.get(index);  } else {
@@ -5931,7 +5931,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrB
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public java.util.List 
+      public java.util.List 
            getObjectPropertiesOrBuilderList() {
         if (objectPropertiesBuilder_ != null) {
           return objectPropertiesBuilder_.getMessageOrBuilderList();
@@ -5942,31 +5942,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrB
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder() {
         return getObjectPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder(
           int index) {
         return getObjectPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectProperties object_properties = 6;
        */
-      public java.util.List 
+      public java.util.List 
            getObjectPropertiesBuilderList() {
         return getObjectPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder> 
           getObjectPropertiesFieldBuilder() {
         if (objectPropertiesBuilder_ == null) {
           objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder>(
                   objectProperties_,
                   ((bitField0_ & 0x00000020) != 0),
                   getParentForChildren(),
@@ -5976,22 +5976,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Bu
         return objectPropertiesBuilder_;
       }
 
-      private java.util.List objectArrayProperties_ =
+      private java.util.List objectArrayProperties_ =
         java.util.Collections.emptyList();
       private void ensureObjectArrayPropertiesIsMutable() {
         if (!((bitField0_ & 0x00000040) != 0)) {
-          objectArrayProperties_ = new java.util.ArrayList(objectArrayProperties_);
+          objectArrayProperties_ = new java.util.ArrayList(objectArrayProperties_);
           bitField0_ |= 0x00000040;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> objectArrayPropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> objectArrayPropertiesBuilder_;
 
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public java.util.List getObjectArrayPropertiesList() {
+      public java.util.List getObjectArrayPropertiesList() {
         if (objectArrayPropertiesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(objectArrayProperties_);
         } else {
@@ -6011,7 +6011,7 @@ public int getObjectArrayPropertiesCount() {
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) {
         if (objectArrayPropertiesBuilder_ == null) {
           return objectArrayProperties_.get(index);
         } else {
@@ -6022,7 +6022,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperti
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder setObjectArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) {
         if (objectArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6039,7 +6039,7 @@ public Builder setObjectArrayProperties(
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder setObjectArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
         if (objectArrayPropertiesBuilder_ == null) {
           ensureObjectArrayPropertiesIsMutable();
           objectArrayProperties_.set(index, builderForValue.build());
@@ -6052,7 +6052,7 @@ public Builder setObjectArrayProperties(
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public Builder addObjectArrayProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) {
+      public Builder addObjectArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) {
         if (objectArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6069,7 +6069,7 @@ public Builder addObjectArrayProperties(io.weaviate.client.grpc.protocol.v1.Weav
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder addObjectArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) {
         if (objectArrayPropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6086,7 +6086,7 @@ public Builder addObjectArrayProperties(
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder addObjectArrayProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
         if (objectArrayPropertiesBuilder_ == null) {
           ensureObjectArrayPropertiesIsMutable();
           objectArrayProperties_.add(builderForValue.build());
@@ -6100,7 +6100,7 @@ public Builder addObjectArrayProperties(
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder addObjectArrayProperties(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) {
         if (objectArrayPropertiesBuilder_ == null) {
           ensureObjectArrayPropertiesIsMutable();
           objectArrayProperties_.add(index, builderForValue.build());
@@ -6114,7 +6114,7 @@ public Builder addObjectArrayProperties(
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
       public Builder addAllObjectArrayProperties(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (objectArrayPropertiesBuilder_ == null) {
           ensureObjectArrayPropertiesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -6154,14 +6154,14 @@ public Builder removeObjectArrayProperties(int index) {
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder getObjectArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder getObjectArrayPropertiesBuilder(
           int index) {
         return getObjectArrayPropertiesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder(
           int index) {
         if (objectArrayPropertiesBuilder_ == null) {
           return objectArrayProperties_.get(index);  } else {
@@ -6171,7 +6171,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperti
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public java.util.List 
+      public java.util.List 
            getObjectArrayPropertiesOrBuilderList() {
         if (objectArrayPropertiesBuilder_ != null) {
           return objectArrayPropertiesBuilder_.getMessageOrBuilderList();
@@ -6182,31 +6182,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperti
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder() {
         return getObjectArrayPropertiesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder(
           int index) {
         return getObjectArrayPropertiesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 7;
        */
-      public java.util.List 
+      public java.util.List 
            getObjectArrayPropertiesBuilderList() {
         return getObjectArrayPropertiesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> 
           getObjectArrayPropertiesFieldBuilder() {
         if (objectArrayPropertiesBuilder_ == null) {
           objectArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder>(
                   objectArrayProperties_,
                   ((bitField0_ & 0x00000040) != 0),
                   getParentForChildren(),
@@ -6343,12 +6343,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectPropertiesValue)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -6384,7 +6384,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -6397,12 +6397,12 @@ public interface ObjectArrayPropertiesOrBuilder extends
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
-    java.util.List 
+    java.util.List 
         getValuesList();
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValues(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValues(int index);
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
@@ -6410,12 +6410,12 @@ public interface ObjectArrayPropertiesOrBuilder extends
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
-    java.util.List 
+    java.util.List 
         getValuesOrBuilderList();
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
         int index);
 
     /**
@@ -6456,32 +6456,32 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
     @SuppressWarnings("serial")
-    private java.util.List values_;
+    private java.util.List values_;
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
     @java.lang.Override
-    public java.util.List getValuesList() {
+    public java.util.List getValuesList() {
       return values_;
     }
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getValuesOrBuilderList() {
       return values_;
     }
@@ -6496,14 +6496,14 @@ public int getValuesCount() {
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValues(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValues(int index) {
       return values_.get(index);
     }
     /**
      * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
         int index) {
       return values_.get(index);
     }
@@ -6593,10 +6593,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -6624,44 +6624,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -6669,26 +6669,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayP
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -6701,7 +6701,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayP
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -6722,21 +6722,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectArrayProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.newBuilder()
       private Builder() {
 
       }
@@ -6764,17 +6764,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectArrayProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -6782,15 +6782,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperti
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties result) {
         if (valuesBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0)) {
             values_ = java.util.Collections.unmodifiableList(values_);
@@ -6802,7 +6802,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000002) != 0)) {
           result.propName_ = propName_;
@@ -6843,16 +6843,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()) return this;
         if (valuesBuilder_ == null) {
           if (!other.values_.isEmpty()) {
             if (values_.isEmpty()) {
@@ -6911,9 +6911,9 @@ public Builder mergeFrom(
                 done = true;
                 break;
               case 10: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.parser(),
                         extensionRegistry);
                 if (valuesBuilder_ == null) {
                   ensureValuesIsMutable();
@@ -6945,22 +6945,22 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private java.util.List values_ =
+      private java.util.List values_ =
         java.util.Collections.emptyList();
       private void ensureValuesIsMutable() {
         if (!((bitField0_ & 0x00000001) != 0)) {
-          values_ = new java.util.ArrayList(values_);
+          values_ = new java.util.ArrayList(values_);
           bitField0_ |= 0x00000001;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> valuesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> valuesBuilder_;
 
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public java.util.List getValuesList() {
+      public java.util.List getValuesList() {
         if (valuesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(values_);
         } else {
@@ -6980,7 +6980,7 @@ public int getValuesCount() {
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValues(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValues(int index) {
         if (valuesBuilder_ == null) {
           return values_.get(index);
         } else {
@@ -6991,7 +6991,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder setValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -7008,7 +7008,7 @@ public Builder setValues(
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder setValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.set(index, builderForValue.build());
@@ -7021,7 +7021,7 @@ public Builder setValues(
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value) {
+      public Builder addValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -7038,7 +7038,7 @@ public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.O
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder addValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -7055,7 +7055,7 @@ public Builder addValues(
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder addValues(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.add(builderForValue.build());
@@ -7069,7 +7069,7 @@ public Builder addValues(
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder addValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.add(index, builderForValue.build());
@@ -7083,7 +7083,7 @@ public Builder addValues(
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
       public Builder addAllValues(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -7123,14 +7123,14 @@ public Builder removeValues(int index) {
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder getValuesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder getValuesBuilder(
           int index) {
         return getValuesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValuesOrBuilder(
           int index) {
         if (valuesBuilder_ == null) {
           return values_.get(index);  } else {
@@ -7140,7 +7140,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public java.util.List 
+      public java.util.List 
            getValuesOrBuilderList() {
         if (valuesBuilder_ != null) {
           return valuesBuilder_.getMessageOrBuilderList();
@@ -7151,31 +7151,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder addValuesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder addValuesBuilder() {
         return getValuesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder addValuesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder addValuesBuilder(
           int index) {
         return getValuesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.ObjectPropertiesValue values = 1;
        */
-      public java.util.List 
+      public java.util.List 
            getValuesBuilderList() {
         return getValuesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> 
           getValuesFieldBuilder() {
         if (valuesBuilder_ == null) {
           valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder>(
                   values_,
                   ((bitField0_ & 0x00000001) != 0),
                   getParentForChildren(),
@@ -7273,12 +7273,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectArrayProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -7314,7 +7314,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectArrayProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -7333,11 +7333,11 @@ public interface ObjectPropertiesOrBuilder extends
      * .weaviate.v1.ObjectPropertiesValue value = 1;
      * @return The value.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValue();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValue();
     /**
      * .weaviate.v1.ObjectPropertiesValue value = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder();
 
     /**
      * string prop_name = 2;
@@ -7376,20 +7376,20 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder.class);
     }
 
     private int bitField0_;
     public static final int VALUE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value_;
     /**
      * .weaviate.v1.ObjectPropertiesValue value = 1;
      * @return Whether the value field is set.
@@ -7403,15 +7403,15 @@ public boolean hasValue() {
      * @return The value.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValue() {
-      return value_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValue() {
+      return value_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
     }
     /**
      * .weaviate.v1.ObjectPropertiesValue value = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder() {
-      return value_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder() {
+      return value_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
     }
 
     public static final int PROP_NAME_FIELD_NUMBER = 2;
@@ -7499,10 +7499,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties) obj;
 
       if (hasValue() != other.hasValue()) return false;
       if (hasValue()) {
@@ -7533,44 +7533,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7578,26 +7578,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProper
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7610,7 +7610,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProper
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -7631,21 +7631,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectProperties)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -7677,17 +7677,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_ObjectProperties_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -7695,14 +7695,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties bu
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -7751,16 +7751,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance()) return this;
         if (other.hasValue()) {
           mergeValue(other.getValue());
         }
@@ -7824,9 +7824,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> valueBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> valueBuilder_;
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        * @return Whether the value field is set.
@@ -7838,9 +7838,9 @@ public boolean hasValue() {
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        * @return The value.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue getValue() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue getValue() {
         if (valueBuilder_ == null) {
-          return value_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
+          return value_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
         } else {
           return valueBuilder_.getMessage();
         }
@@ -7848,7 +7848,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
-      public Builder setValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value) {
+      public Builder setValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value) {
         if (valueBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -7865,7 +7865,7 @@ public Builder setValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Ob
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
       public Builder setValue(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder builderForValue) {
         if (valueBuilder_ == null) {
           value_ = builderForValue.build();
         } else {
@@ -7878,11 +7878,11 @@ public Builder setValue(
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
-      public Builder mergeValue(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue value) {
+      public Builder mergeValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue value) {
         if (valueBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             value_ != null &&
-            value_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance()) {
+            value_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance()) {
             getValueBuilder().mergeFrom(value);
           } else {
             value_ = value;
@@ -7912,7 +7912,7 @@ public Builder clearValue() {
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder getValueBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder getValueBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getValueFieldBuilder().getBuilder();
@@ -7920,23 +7920,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesVal
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder getValueOrBuilder() {
         if (valueBuilder_ != null) {
           return valueBuilder_.getMessageOrBuilder();
         } else {
           return value_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.getDefaultInstance() : value_;
         }
       }
       /**
        * .weaviate.v1.ObjectPropertiesValue value = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder> 
           getValueFieldBuilder() {
         if (valueBuilder_ == null) {
           valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectPropertiesValueOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesValueOrBuilder>(
                   getValue(),
                   getParentForChildren(),
                   isClean());
@@ -8033,12 +8033,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectProperties)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -8074,7 +8074,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ObjectProperties getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -8135,15 +8135,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -8227,10 +8227,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -8254,44 +8254,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8299,26 +8299,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray pa
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8331,7 +8331,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray pa
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -8352,21 +8352,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.TextArray)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.newBuilder()
       private Builder() {
 
       }
@@ -8388,17 +8388,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_TextArray_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -8406,14 +8406,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray build() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -8455,16 +8455,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -8651,12 +8651,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.TextArray)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -8692,7 +8692,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -8744,15 +8744,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -8840,10 +8840,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -8867,44 +8867,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8912,26 +8912,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray par
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -8944,7 +8944,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray par
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -8965,21 +8965,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.IntArray)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.newBuilder()
       private Builder() {
 
       }
@@ -9000,17 +9000,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_IntArray_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -9018,14 +9018,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray build() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -9067,16 +9067,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -9247,12 +9247,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.IntArray)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9288,7 +9288,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9340,15 +9340,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -9433,10 +9433,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -9460,44 +9460,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9505,26 +9505,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9537,7 +9537,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -9558,21 +9558,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NumberArray)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.newBuilder()
       private Builder() {
 
       }
@@ -9593,17 +9593,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_NumberArray_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -9611,14 +9611,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray build()
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -9660,16 +9660,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -9847,12 +9847,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NumberArray)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9888,7 +9888,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9940,15 +9940,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
@@ -10033,10 +10033,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -10060,44 +10060,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10105,26 +10105,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10137,7 +10137,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -10158,21 +10158,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.BooleanArray)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.newBuilder()
       private Builder() {
 
       }
@@ -10193,17 +10193,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_BooleanArray_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -10211,14 +10211,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray build(
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           values_.makeImmutable();
@@ -10260,16 +10260,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance()) return this;
         if (!other.values_.isEmpty()) {
           if (values_.isEmpty()) {
             values_ = other.values_;
@@ -10447,12 +10447,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.BooleanArray)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -10488,7 +10488,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -10507,7 +10507,7 @@ public interface FiltersOrBuilder extends
      * .weaviate.v1.Filters.Operator operator = 1;
      * @return The operator.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator getOperator();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator getOperator();
 
     /**
      * 
@@ -10516,7 +10516,7 @@ public interface FiltersOrBuilder extends
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @return A list containing the on.
      */
     @java.lang.Deprecated java.util.List
@@ -10528,7 +10528,7 @@ public interface FiltersOrBuilder extends
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @return The count of on.
      */
     @java.lang.Deprecated int getOnCount();
@@ -10539,7 +10539,7 @@ public interface FiltersOrBuilder extends
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @param index The index of the element to return.
      * @return The on at the given index.
      */
@@ -10551,7 +10551,7 @@ public interface FiltersOrBuilder extends
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @param index The index of the value to return.
      * @return The bytes of the on at the given index.
      */
@@ -10561,12 +10561,12 @@ public interface FiltersOrBuilder extends
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
-    java.util.List 
+    java.util.List 
         getFiltersList();
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(int index);
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
@@ -10574,12 +10574,12 @@ public interface FiltersOrBuilder extends
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
-    java.util.List 
+    java.util.List 
         getFiltersOrBuilderList();
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
         int index);
 
     /**
@@ -10641,11 +10641,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.TextArray value_text_array = 9;
      * @return The valueTextArray.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getValueTextArray();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getValueTextArray();
     /**
      * .weaviate.v1.TextArray value_text_array = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder();
 
     /**
      * .weaviate.v1.IntArray value_int_array = 10;
@@ -10656,11 +10656,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.IntArray value_int_array = 10;
      * @return The valueIntArray.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getValueIntArray();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getValueIntArray();
     /**
      * .weaviate.v1.IntArray value_int_array = 10;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder();
 
     /**
      * .weaviate.v1.BooleanArray value_boolean_array = 11;
@@ -10671,11 +10671,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.BooleanArray value_boolean_array = 11;
      * @return The valueBooleanArray.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getValueBooleanArray();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getValueBooleanArray();
     /**
      * .weaviate.v1.BooleanArray value_boolean_array = 11;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder();
 
     /**
      * .weaviate.v1.NumberArray value_number_array = 12;
@@ -10686,11 +10686,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.NumberArray value_number_array = 12;
      * @return The valueNumberArray.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getValueNumberArray();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getValueNumberArray();
     /**
      * .weaviate.v1.NumberArray value_number_array = 12;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder();
 
     /**
      * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
@@ -10701,11 +10701,11 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
      * @return The valueGeo.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo();
     /**
      * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder();
 
     /**
      * 
@@ -10724,7 +10724,7 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      * .weaviate.v1.FilterTarget target = 20;
      * @return The target.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget();
     /**
      * 
      * leave space for more filter values
@@ -10732,9 +10732,9 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFilter
      *
      * .weaviate.v1.FilterTarget target = 20;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.TestValueCase getTestValueCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.TestValueCase getTestValueCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.Filters}
@@ -10764,15 +10764,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Filters_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Filters_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder.class);
     }
 
     /**
@@ -10983,7 +10983,7 @@ public Operator findValueByNumber(int number) {
       }
       public static final com.google.protobuf.Descriptors.EnumDescriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDescriptor().getEnumTypes().get(0);
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDescriptor().getEnumTypes().get(0);
       }
 
       private static final Operator[] VALUES = values();
@@ -11079,9 +11079,9 @@ public int getNumber() {
      * .weaviate.v1.Filters.Operator operator = 1;
      * @return The operator.
      */
-    @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator getOperator() {
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.forNumber(operator_);
-      return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.UNRECOGNIZED : result;
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator getOperator() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.forNumber(operator_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.UNRECOGNIZED : result;
     }
 
     public static final int ON_FIELD_NUMBER = 2;
@@ -11095,7 +11095,7 @@ public int getNumber() {
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @return A list containing the on.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -11109,7 +11109,7 @@ public int getNumber() {
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @return The count of on.
      */
     @java.lang.Deprecated public int getOnCount() {
@@ -11122,7 +11122,7 @@ public int getNumber() {
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @param index The index of the element to return.
      * @return The on at the given index.
      */
@@ -11136,7 +11136,7 @@ public int getNumber() {
      *
      * repeated string on = 2 [deprecated = true];
      * @deprecated weaviate.v1.Filters.on is deprecated.
-     *     See v1/base.proto;l=99
+     *     See v1/base.proto;l=98
      * @param index The index of the value to return.
      * @return The bytes of the on at the given index.
      */
@@ -11147,19 +11147,19 @@ public int getNumber() {
 
     public static final int FILTERS_FIELD_NUMBER = 3;
     @SuppressWarnings("serial")
-    private java.util.List filters_;
+    private java.util.List filters_;
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
     @java.lang.Override
-    public java.util.List getFiltersList() {
+    public java.util.List getFiltersList() {
       return filters_;
     }
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getFiltersOrBuilderList() {
       return filters_;
     }
@@ -11174,14 +11174,14 @@ public int getFiltersCount() {
      * repeated .weaviate.v1.Filters filters = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(int index) {
       return filters_.get(index);
     }
     /**
      * repeated .weaviate.v1.Filters filters = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
         int index) {
       return filters_.get(index);
     }
@@ -11315,21 +11315,21 @@ public boolean hasValueTextArray() {
      * @return The valueTextArray.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getValueTextArray() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getValueTextArray() {
       if (testValueCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
     }
     /**
      * .weaviate.v1.TextArray value_text_array = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder() {
       if (testValueCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
     }
 
     public static final int VALUE_INT_ARRAY_FIELD_NUMBER = 10;
@@ -11346,21 +11346,21 @@ public boolean hasValueIntArray() {
      * @return The valueIntArray.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getValueIntArray() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getValueIntArray() {
       if (testValueCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
     }
     /**
      * .weaviate.v1.IntArray value_int_array = 10;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder() {
       if (testValueCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
     }
 
     public static final int VALUE_BOOLEAN_ARRAY_FIELD_NUMBER = 11;
@@ -11377,21 +11377,21 @@ public boolean hasValueBooleanArray() {
      * @return The valueBooleanArray.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getValueBooleanArray() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getValueBooleanArray() {
       if (testValueCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
     }
     /**
      * .weaviate.v1.BooleanArray value_boolean_array = 11;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder() {
       if (testValueCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
     }
 
     public static final int VALUE_NUMBER_ARRAY_FIELD_NUMBER = 12;
@@ -11408,21 +11408,21 @@ public boolean hasValueNumberArray() {
      * @return The valueNumberArray.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getValueNumberArray() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getValueNumberArray() {
       if (testValueCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
     }
     /**
      * .weaviate.v1.NumberArray value_number_array = 12;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder() {
       if (testValueCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
     }
 
     public static final int VALUE_GEO_FIELD_NUMBER = 13;
@@ -11439,25 +11439,25 @@ public boolean hasValueGeo() {
      * @return The valueGeo.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo() {
       if (testValueCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder() {
       if (testValueCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
     }
 
     public static final int TARGET_FIELD_NUMBER = 20;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
     /**
      * 
      * leave space for more filter values
@@ -11479,8 +11479,8 @@ public boolean hasTarget() {
      * @return The target.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
     /**
      * 
@@ -11490,8 +11490,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTar
      * .weaviate.v1.FilterTarget target = 20;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -11508,7 +11508,7 @@ public final boolean isInitialized() {
     @java.lang.Override
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
-      if (operator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
+      if (operator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
         output.writeEnum(1, operator_);
       }
       for (int i = 0; i < on_.size(); i++) {
@@ -11533,19 +11533,19 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
             7, (double)((java.lang.Double) testValue_));
       }
       if (testValueCase_ == 9) {
-        output.writeMessage(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_);
+        output.writeMessage(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_);
       }
       if (testValueCase_ == 10) {
-        output.writeMessage(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_);
+        output.writeMessage(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_);
       }
       if (testValueCase_ == 11) {
-        output.writeMessage(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_);
+        output.writeMessage(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_);
       }
       if (testValueCase_ == 12) {
-        output.writeMessage(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_);
+        output.writeMessage(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_);
       }
       if (testValueCase_ == 13) {
-        output.writeMessage(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_);
+        output.writeMessage(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_);
       }
       if (((bitField0_ & 0x00000001) != 0)) {
         output.writeMessage(20, getTarget());
@@ -11559,7 +11559,7 @@ public int getSerializedSize() {
       if (size != -1) return size;
 
       size = 0;
-      if (operator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
+      if (operator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
         size += com.google.protobuf.CodedOutputStream
           .computeEnumSize(1, operator_);
       }
@@ -11595,23 +11595,23 @@ public int getSerializedSize() {
       }
       if (testValueCase_ == 9) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_);
+          .computeMessageSize(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_);
       }
       if (testValueCase_ == 10) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_);
+          .computeMessageSize(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_);
       }
       if (testValueCase_ == 11) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_);
+          .computeMessageSize(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_);
       }
       if (testValueCase_ == 12) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_);
+          .computeMessageSize(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_);
       }
       if (testValueCase_ == 13) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_);
+          .computeMessageSize(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_);
       }
       if (((bitField0_ & 0x00000001) != 0)) {
         size += com.google.protobuf.CodedOutputStream
@@ -11627,10 +11627,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters) obj;
 
       if (operator_ != other.operator_) return false;
       if (!getOnList()
@@ -11757,44 +11757,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -11802,26 +11802,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters pars
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -11834,7 +11834,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters pars
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -11855,21 +11855,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.Filters)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Filters_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Filters_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -11928,17 +11928,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Filters_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -11946,8 +11946,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters build() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
@@ -11955,7 +11955,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters buildPartia
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters result) {
         if (filtersBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0)) {
             filters_ = java.util.Collections.unmodifiableList(filters_);
@@ -11967,7 +11967,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.operator_ = operator_;
@@ -11986,7 +11986,7 @@ private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
         result.bitField0_ |= to_bitField0_;
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters result) {
         result.testValueCase_ = testValueCase_;
         result.testValue_ = this.testValue_;
         if (testValueCase_ == 9 &&
@@ -12045,16 +12045,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance()) return this;
         if (other.operator_ != 0) {
           setOperatorValue(other.getOperatorValue());
         }
@@ -12178,9 +12178,9 @@ public Builder mergeFrom(
                 break;
               } // case 18
               case 26: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.parser(),
                         extensionRegistry);
                 if (filtersBuilder_ == null) {
                   ensureFiltersIsMutable();
@@ -12309,16 +12309,16 @@ public Builder setOperatorValue(int value) {
        * @return The operator.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator getOperator() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.forNumber(operator_);
-        return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator.UNRECOGNIZED : result;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator getOperator() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.forNumber(operator_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator.UNRECOGNIZED : result;
       }
       /**
        * .weaviate.v1.Filters.Operator operator = 1;
        * @param value The operator to set.
        * @return This builder for chaining.
        */
-      public Builder setOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Operator value) {
+      public Builder setOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Operator value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -12353,7 +12353,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @return A list containing the on.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -12368,7 +12368,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @return The count of on.
        */
       @java.lang.Deprecated public int getOnCount() {
@@ -12381,7 +12381,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param index The index of the element to return.
        * @return The on at the given index.
        */
@@ -12395,7 +12395,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param index The index of the value to return.
        * @return The bytes of the on at the given index.
        */
@@ -12410,7 +12410,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param index The index to set the value at.
        * @param value The on to set.
        * @return This builder for chaining.
@@ -12431,7 +12431,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param value The on to add.
        * @return This builder for chaining.
        */
@@ -12451,7 +12451,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param values The on to add.
        * @return This builder for chaining.
        */
@@ -12471,7 +12471,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearOn() {
@@ -12488,7 +12488,7 @@ private void ensureOnIsMutable() {
        *
        * repeated string on = 2 [deprecated = true];
        * @deprecated weaviate.v1.Filters.on is deprecated.
-       *     See v1/base.proto;l=99
+       *     See v1/base.proto;l=98
        * @param value The bytes of the on to add.
        * @return This builder for chaining.
        */
@@ -12503,22 +12503,22 @@ private void ensureOnIsMutable() {
         return this;
       }
 
-      private java.util.List filters_ =
+      private java.util.List filters_ =
         java.util.Collections.emptyList();
       private void ensureFiltersIsMutable() {
         if (!((bitField0_ & 0x00000004) != 0)) {
-          filters_ = new java.util.ArrayList(filters_);
+          filters_ = new java.util.ArrayList(filters_);
           bitField0_ |= 0x00000004;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_;
 
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public java.util.List getFiltersList() {
+      public java.util.List getFiltersList() {
         if (filtersBuilder_ == null) {
           return java.util.Collections.unmodifiableList(filters_);
         } else {
@@ -12538,7 +12538,7 @@ public int getFiltersCount() {
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(int index) {
         if (filtersBuilder_ == null) {
           return filters_.get(index);
         } else {
@@ -12549,7 +12549,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder setFilters(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) {
         if (filtersBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -12566,7 +12566,7 @@ public Builder setFilters(
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder setFilters(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) {
         if (filtersBuilder_ == null) {
           ensureFiltersIsMutable();
           filters_.set(index, builderForValue.build());
@@ -12579,7 +12579,7 @@ public Builder setFilters(
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public Builder addFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) {
+      public Builder addFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) {
         if (filtersBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -12596,7 +12596,7 @@ public Builder addFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder addFilters(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) {
         if (filtersBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -12613,7 +12613,7 @@ public Builder addFilters(
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder addFilters(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) {
         if (filtersBuilder_ == null) {
           ensureFiltersIsMutable();
           filters_.add(builderForValue.build());
@@ -12627,7 +12627,7 @@ public Builder addFilters(
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder addFilters(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) {
         if (filtersBuilder_ == null) {
           ensureFiltersIsMutable();
           filters_.add(index, builderForValue.build());
@@ -12641,7 +12641,7 @@ public Builder addFilters(
        * repeated .weaviate.v1.Filters filters = 3;
        */
       public Builder addAllFilters(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (filtersBuilder_ == null) {
           ensureFiltersIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -12681,14 +12681,14 @@ public Builder removeFilters(int index) {
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder getFiltersBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder getFiltersBuilder(
           int index) {
         return getFiltersFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(
           int index) {
         if (filtersBuilder_ == null) {
           return filters_.get(index);  } else {
@@ -12698,7 +12698,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder ge
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getFiltersOrBuilderList() {
         if (filtersBuilder_ != null) {
           return filtersBuilder_.getMessageOrBuilderList();
@@ -12709,31 +12709,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder ge
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder addFiltersBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder addFiltersBuilder() {
         return getFiltersFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder addFiltersBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder addFiltersBuilder(
           int index) {
         return getFiltersFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Filters filters = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getFiltersBuilderList() {
         return getFiltersFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> 
           getFiltersFieldBuilder() {
         if (filtersBuilder_ == null) {
           filtersBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder>(
                   filters_,
                   ((bitField0_ & 0x00000004) != 0),
                   getParentForChildren(),
@@ -12963,7 +12963,7 @@ public Builder clearValueNumber() {
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> valueTextArrayBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> valueTextArrayBuilder_;
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        * @return Whether the valueTextArray field is set.
@@ -12977,23 +12977,23 @@ public boolean hasValueTextArray() {
        * @return The valueTextArray.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getValueTextArray() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getValueTextArray() {
         if (valueTextArrayBuilder_ == null) {
           if (testValueCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
         } else {
           if (testValueCase_ == 9) {
             return valueTextArrayBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        */
-      public Builder setValueTextArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setValueTextArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (valueTextArrayBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13010,7 +13010,7 @@ public Builder setValueTextArray(io.weaviate.client.grpc.protocol.v1.WeaviatePro
        * .weaviate.v1.TextArray value_text_array = 9;
        */
       public Builder setValueTextArray(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (valueTextArrayBuilder_ == null) {
           testValue_ = builderForValue.build();
           onChanged();
@@ -13023,11 +13023,11 @@ public Builder setValueTextArray(
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        */
-      public Builder mergeValueTextArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeValueTextArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (valueTextArrayBuilder_ == null) {
           if (testValueCase_ == 9 &&
-              testValue_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_)
+              testValue_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_)
                 .mergeFrom(value).buildPartial();
           } else {
             testValue_ = value;
@@ -13065,36 +13065,36 @@ public Builder clearValueTextArray() {
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getValueTextArrayBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getValueTextArrayBuilder() {
         return getValueTextArrayFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getValueTextArrayOrBuilder() {
         if ((testValueCase_ == 9) && (valueTextArrayBuilder_ != null)) {
           return valueTextArrayBuilder_.getMessageOrBuilder();
         } else {
           if (testValueCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.TextArray value_text_array = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getValueTextArrayFieldBuilder() {
         if (valueTextArrayBuilder_ == null) {
           if (!(testValueCase_ == 9)) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance();
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance();
           }
           valueTextArrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray) testValue_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray) testValue_,
                   getParentForChildren(),
                   isClean());
           testValue_ = null;
@@ -13105,7 +13105,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder> valueIntArrayBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder> valueIntArrayBuilder_;
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        * @return Whether the valueIntArray field is set.
@@ -13119,23 +13119,23 @@ public boolean hasValueIntArray() {
        * @return The valueIntArray.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray getValueIntArray() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray getValueIntArray() {
         if (valueIntArrayBuilder_ == null) {
           if (testValueCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
         } else {
           if (testValueCase_ == 10) {
             return valueIntArrayBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        */
-      public Builder setValueIntArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray value) {
+      public Builder setValueIntArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray value) {
         if (valueIntArrayBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13152,7 +13152,7 @@ public Builder setValueIntArray(io.weaviate.client.grpc.protocol.v1.WeaviateProt
        * .weaviate.v1.IntArray value_int_array = 10;
        */
       public Builder setValueIntArray(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder builderForValue) {
         if (valueIntArrayBuilder_ == null) {
           testValue_ = builderForValue.build();
           onChanged();
@@ -13165,11 +13165,11 @@ public Builder setValueIntArray(
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        */
-      public Builder mergeValueIntArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray value) {
+      public Builder mergeValueIntArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray value) {
         if (valueIntArrayBuilder_ == null) {
           if (testValueCase_ == 10 &&
-              testValue_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance()) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_)
+              testValue_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance()) {
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_)
                 .mergeFrom(value).buildPartial();
           } else {
             testValue_ = value;
@@ -13207,36 +13207,36 @@ public Builder clearValueIntArray() {
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder getValueIntArrayBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder getValueIntArrayBuilder() {
         return getValueIntArrayFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder getValueIntArrayOrBuilder() {
         if ((testValueCase_ == 10) && (valueIntArrayBuilder_ != null)) {
           return valueIntArrayBuilder_.getMessageOrBuilder();
         } else {
           if (testValueCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.IntArray value_int_array = 10;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder> 
           getValueIntArrayFieldBuilder() {
         if (valueIntArrayBuilder_ == null) {
           if (!(testValueCase_ == 10)) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.getDefaultInstance();
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.getDefaultInstance();
           }
           valueIntArrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArray) testValue_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArray) testValue_,
                   getParentForChildren(),
                   isClean());
           testValue_ = null;
@@ -13247,7 +13247,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.IntArrayOrBuilder g
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder> valueBooleanArrayBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder> valueBooleanArrayBuilder_;
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        * @return Whether the valueBooleanArray field is set.
@@ -13261,23 +13261,23 @@ public boolean hasValueBooleanArray() {
        * @return The valueBooleanArray.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray getValueBooleanArray() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray getValueBooleanArray() {
         if (valueBooleanArrayBuilder_ == null) {
           if (testValueCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
         } else {
           if (testValueCase_ == 11) {
             return valueBooleanArrayBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
-      public Builder setValueBooleanArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray value) {
+      public Builder setValueBooleanArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray value) {
         if (valueBooleanArrayBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13294,7 +13294,7 @@ public Builder setValueBooleanArray(io.weaviate.client.grpc.protocol.v1.Weaviate
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
       public Builder setValueBooleanArray(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder builderForValue) {
         if (valueBooleanArrayBuilder_ == null) {
           testValue_ = builderForValue.build();
           onChanged();
@@ -13307,11 +13307,11 @@ public Builder setValueBooleanArray(
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
-      public Builder mergeValueBooleanArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray value) {
+      public Builder mergeValueBooleanArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray value) {
         if (valueBooleanArrayBuilder_ == null) {
           if (testValueCase_ == 11 &&
-              testValue_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance()) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_)
+              testValue_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance()) {
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_)
                 .mergeFrom(value).buildPartial();
           } else {
             testValue_ = value;
@@ -13349,36 +13349,36 @@ public Builder clearValueBooleanArray() {
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder getValueBooleanArrayBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder getValueBooleanArrayBuilder() {
         return getValueBooleanArrayFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder getValueBooleanArrayOrBuilder() {
         if ((testValueCase_ == 11) && (valueBooleanArrayBuilder_ != null)) {
           return valueBooleanArrayBuilder_.getMessageOrBuilder();
         } else {
           if (testValueCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.BooleanArray value_boolean_array = 11;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder> 
           getValueBooleanArrayFieldBuilder() {
         if (valueBooleanArrayBuilder_ == null) {
           if (!(testValueCase_ == 11)) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.getDefaultInstance();
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.getDefaultInstance();
           }
           valueBooleanArrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArray) testValue_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArray) testValue_,
                   getParentForChildren(),
                   isClean());
           testValue_ = null;
@@ -13389,7 +13389,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.BooleanArrayOrBuild
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder> valueNumberArrayBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder> valueNumberArrayBuilder_;
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        * @return Whether the valueNumberArray field is set.
@@ -13403,23 +13403,23 @@ public boolean hasValueNumberArray() {
        * @return The valueNumberArray.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray getValueNumberArray() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray getValueNumberArray() {
         if (valueNumberArrayBuilder_ == null) {
           if (testValueCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
         } else {
           if (testValueCase_ == 12) {
             return valueNumberArrayBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
-      public Builder setValueNumberArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray value) {
+      public Builder setValueNumberArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray value) {
         if (valueNumberArrayBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13436,7 +13436,7 @@ public Builder setValueNumberArray(io.weaviate.client.grpc.protocol.v1.WeaviateP
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
       public Builder setValueNumberArray(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder builderForValue) {
         if (valueNumberArrayBuilder_ == null) {
           testValue_ = builderForValue.build();
           onChanged();
@@ -13449,11 +13449,11 @@ public Builder setValueNumberArray(
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
-      public Builder mergeValueNumberArray(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray value) {
+      public Builder mergeValueNumberArray(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray value) {
         if (valueNumberArrayBuilder_ == null) {
           if (testValueCase_ == 12 &&
-              testValue_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance()) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_)
+              testValue_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance()) {
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_)
                 .mergeFrom(value).buildPartial();
           } else {
             testValue_ = value;
@@ -13491,36 +13491,36 @@ public Builder clearValueNumberArray() {
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder getValueNumberArrayBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder getValueNumberArrayBuilder() {
         return getValueNumberArrayFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder getValueNumberArrayOrBuilder() {
         if ((testValueCase_ == 12) && (valueNumberArrayBuilder_ != null)) {
           return valueNumberArrayBuilder_.getMessageOrBuilder();
         } else {
           if (testValueCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.NumberArray value_number_array = 12;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder> 
           getValueNumberArrayFieldBuilder() {
         if (valueNumberArrayBuilder_ == null) {
           if (!(testValueCase_ == 12)) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.getDefaultInstance();
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.getDefaultInstance();
           }
           valueNumberArrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArray) testValue_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArray) testValue_,
                   getParentForChildren(),
                   isClean());
           testValue_ = null;
@@ -13531,7 +13531,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.NumberArrayOrBuilde
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> valueGeoBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> valueGeoBuilder_;
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        * @return Whether the valueGeo field is set.
@@ -13545,23 +13545,23 @@ public boolean hasValueGeo() {
        * @return The valueGeo.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getValueGeo() {
         if (valueGeoBuilder_ == null) {
           if (testValueCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
         } else {
           if (testValueCase_ == 13) {
             return valueGeoBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
-      public Builder setValueGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter value) {
+      public Builder setValueGeo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter value) {
         if (valueGeoBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13578,7 +13578,7 @@ public Builder setValueGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
       public Builder setValueGeo(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder builderForValue) {
         if (valueGeoBuilder_ == null) {
           testValue_ = builderForValue.build();
           onChanged();
@@ -13591,11 +13591,11 @@ public Builder setValueGeo(
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
-      public Builder mergeValueGeo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter value) {
+      public Builder mergeValueGeo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter value) {
         if (valueGeoBuilder_ == null) {
           if (testValueCase_ == 13 &&
-              testValue_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_)
+              testValue_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) {
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_)
                 .mergeFrom(value).buildPartial();
           } else {
             testValue_ = value;
@@ -13633,36 +13633,36 @@ public Builder clearValueGeo() {
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder getValueGeoBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder getValueGeoBuilder() {
         return getValueGeoFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder getValueGeoOrBuilder() {
         if ((testValueCase_ == 13) && (valueGeoBuilder_ != null)) {
           return valueGeoBuilder_.getMessageOrBuilder();
         } else {
           if (testValueCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GeoCoordinatesFilter value_geo = 13;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder> 
           getValueGeoFieldBuilder() {
         if (valueGeoBuilder_ == null) {
           if (!(testValueCase_ == 13)) {
-            testValue_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+            testValue_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
           }
           valueGeoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) testValue_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) testValue_,
                   getParentForChildren(),
                   isClean());
           testValue_ = null;
@@ -13672,9 +13672,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilte
         return valueGeoBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
       /**
        * 
        * leave space for more filter values
@@ -13694,9 +13694,9 @@ public boolean hasTarget() {
        * .weaviate.v1.FilterTarget target = 20;
        * @return The target.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
         if (targetBuilder_ == null) {
-          return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+          return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         } else {
           return targetBuilder_.getMessage();
         }
@@ -13708,7 +13708,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTar
        *
        * .weaviate.v1.FilterTarget target = 20;
        */
-      public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder setTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13729,7 +13729,7 @@ public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.F
        * .weaviate.v1.FilterTarget target = 20;
        */
       public Builder setTarget(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
         if (targetBuilder_ == null) {
           target_ = builderForValue.build();
         } else {
@@ -13746,11 +13746,11 @@ public Builder setTarget(
        *
        * .weaviate.v1.FilterTarget target = 20;
        */
-      public Builder mergeTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder mergeTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (((bitField0_ & 0x00001000) != 0) &&
             target_ != null &&
-            target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
+            target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
             getTargetBuilder().mergeFrom(value);
           } else {
             target_ = value;
@@ -13788,7 +13788,7 @@ public Builder clearTarget() {
        *
        * .weaviate.v1.FilterTarget target = 20;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
         bitField0_ |= 0x00001000;
         onChanged();
         return getTargetFieldBuilder().getBuilder();
@@ -13800,12 +13800,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builde
        *
        * .weaviate.v1.FilterTarget target = 20;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
         if (targetBuilder_ != null) {
           return targetBuilder_.getMessageOrBuilder();
         } else {
           return target_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         }
       }
       /**
@@ -13816,11 +13816,11 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuild
        * .weaviate.v1.FilterTarget target = 20;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> 
           getTargetFieldBuilder() {
         if (targetBuilder_ == null) {
           targetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder>(
                   getTarget(),
                   getParentForChildren(),
                   isClean());
@@ -13845,12 +13845,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.Filters)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13886,7 +13886,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13917,11 +13917,11 @@ public interface FilterReferenceSingleTargetOrBuilder extends
      * .weaviate.v1.FilterTarget target = 2;
      * @return The target.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget();
     /**
      * .weaviate.v1.FilterTarget target = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.FilterReferenceSingleTarget}
@@ -13948,15 +13948,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder.class);
     }
 
     private int bitField0_;
@@ -14000,7 +14000,7 @@ public java.lang.String getOn() {
     }
 
     public static final int TARGET_FIELD_NUMBER = 2;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
     /**
      * .weaviate.v1.FilterTarget target = 2;
      * @return Whether the target field is set.
@@ -14014,15 +14014,15 @@ public boolean hasTarget() {
      * @return The target.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
     /**
      * .weaviate.v1.FilterTarget target = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -14071,10 +14071,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) obj;
 
       if (!getOn()
           .equals(other.getOn())) return false;
@@ -14105,44 +14105,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14150,26 +14150,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14182,7 +14182,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -14203,21 +14203,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.FilterReferenceSingleTarget)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -14249,17 +14249,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceSingleTarget_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -14267,14 +14267,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSing
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.on_ = on_;
@@ -14323,16 +14323,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance()) return this;
         if (!other.getOn().isEmpty()) {
           on_ = other.on_;
           bitField0_ |= 0x00000001;
@@ -14468,9 +14468,9 @@ public Builder setOnBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
       /**
        * .weaviate.v1.FilterTarget target = 2;
        * @return Whether the target field is set.
@@ -14482,9 +14482,9 @@ public boolean hasTarget() {
        * .weaviate.v1.FilterTarget target = 2;
        * @return The target.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
         if (targetBuilder_ == null) {
-          return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+          return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         } else {
           return targetBuilder_.getMessage();
         }
@@ -14492,7 +14492,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTar
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder setTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -14509,7 +14509,7 @@ public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.F
        * .weaviate.v1.FilterTarget target = 2;
        */
       public Builder setTarget(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
         if (targetBuilder_ == null) {
           target_ = builderForValue.build();
         } else {
@@ -14522,11 +14522,11 @@ public Builder setTarget(
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public Builder mergeTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder mergeTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0) &&
             target_ != null &&
-            target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
+            target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
             getTargetBuilder().mergeFrom(value);
           } else {
             target_ = value;
@@ -14556,7 +14556,7 @@ public Builder clearTarget() {
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getTargetFieldBuilder().getBuilder();
@@ -14564,23 +14564,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builde
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
         if (targetBuilder_ != null) {
           return targetBuilder_.getMessageOrBuilder();
         } else {
           return target_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         }
       }
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> 
           getTargetFieldBuilder() {
         if (targetBuilder_ == null) {
           targetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder>(
                   getTarget(),
                   getParentForChildren(),
                   isClean());
@@ -14605,12 +14605,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.FilterReferenceSingleTarget)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14646,7 +14646,7 @@ public com.google.protobuf.Parser getParserForType(
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14677,11 +14677,11 @@ public interface FilterReferenceMultiTargetOrBuilder extends
      * .weaviate.v1.FilterTarget target = 2;
      * @return The target.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget();
     /**
      * .weaviate.v1.FilterTarget target = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder();
 
     /**
      * string target_collection = 3;
@@ -14721,15 +14721,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder.class);
     }
 
     private int bitField0_;
@@ -14773,7 +14773,7 @@ public java.lang.String getOn() {
     }
 
     public static final int TARGET_FIELD_NUMBER = 2;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
     /**
      * .weaviate.v1.FilterTarget target = 2;
      * @return Whether the target field is set.
@@ -14787,15 +14787,15 @@ public boolean hasTarget() {
      * @return The target.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
     /**
      * .weaviate.v1.FilterTarget target = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
-      return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
     }
 
     public static final int TARGET_COLLECTION_FIELD_NUMBER = 3;
@@ -14889,10 +14889,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) obj;
 
       if (!getOn()
           .equals(other.getOn())) return false;
@@ -14927,44 +14927,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14972,26 +14972,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15004,7 +15004,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -15025,21 +15025,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.FilterReferenceMultiTarget)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -15072,17 +15072,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceMultiTarget_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -15090,14 +15090,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMult
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.on_ = on_;
@@ -15149,16 +15149,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance()) return this;
         if (!other.getOn().isEmpty()) {
           on_ = other.on_;
           bitField0_ |= 0x00000001;
@@ -15304,9 +15304,9 @@ public Builder setOnBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget target_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget target_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> targetBuilder_;
       /**
        * .weaviate.v1.FilterTarget target = 2;
        * @return Whether the target field is set.
@@ -15318,9 +15318,9 @@ public boolean hasTarget() {
        * .weaviate.v1.FilterTarget target = 2;
        * @return The target.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTarget() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getTarget() {
         if (targetBuilder_ == null) {
-          return target_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+          return target_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         } else {
           return targetBuilder_.getMessage();
         }
@@ -15328,7 +15328,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getTar
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder setTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -15345,7 +15345,7 @@ public Builder setTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.F
        * .weaviate.v1.FilterTarget target = 2;
        */
       public Builder setTarget(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder builderForValue) {
         if (targetBuilder_ == null) {
           target_ = builderForValue.build();
         } else {
@@ -15358,11 +15358,11 @@ public Builder setTarget(
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public Builder mergeTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget value) {
+      public Builder mergeTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget value) {
         if (targetBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0) &&
             target_ != null &&
-            target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
+            target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance()) {
             getTargetBuilder().mergeFrom(value);
           } else {
             target_ = value;
@@ -15392,7 +15392,7 @@ public Builder clearTarget() {
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder getTargetBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getTargetFieldBuilder().getBuilder();
@@ -15400,23 +15400,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builde
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder getTargetOrBuilder() {
         if (targetBuilder_ != null) {
           return targetBuilder_.getMessageOrBuilder();
         } else {
           return target_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance() : target_;
         }
       }
       /**
        * .weaviate.v1.FilterTarget target = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder> 
           getTargetFieldBuilder() {
         if (targetBuilder_ == null) {
           targetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder>(
                   getTarget(),
                   getParentForChildren(),
                   isClean());
@@ -15513,12 +15513,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.FilterReferenceMultiTarget)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -15554,7 +15554,7 @@ public com.google.protobuf.Parser getParserForType()
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -15601,15 +15601,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder.class);
     }
 
     public static final int ON_FIELD_NUMBER = 1;
@@ -15690,10 +15690,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) obj;
 
       if (!getOn()
           .equals(other.getOn())) return false;
@@ -15715,44 +15715,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15760,26 +15760,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15792,7 +15792,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterRefere
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -15813,21 +15813,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.FilterReferenceCount)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.newBuilder()
       private Builder() {
 
       }
@@ -15848,17 +15848,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterReferenceCount_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -15866,14 +15866,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCoun
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.on_ = on_;
@@ -15914,16 +15914,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance()) return this;
         if (!other.getOn().isEmpty()) {
           on_ = other.on_;
           bitField0_ |= 0x00000001;
@@ -16065,12 +16065,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.FilterReferenceCount)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16106,7 +16106,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16142,11 +16142,11 @@ public interface FilterTargetOrBuilder extends
      * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
      * @return The singleTarget.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget();
     /**
      * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder();
 
     /**
      * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
@@ -16157,11 +16157,11 @@ public interface FilterTargetOrBuilder extends
      * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
      * @return The multiTarget.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget();
     /**
      * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder();
 
     /**
      * .weaviate.v1.FilterReferenceCount count = 4;
@@ -16172,13 +16172,13 @@ public interface FilterTargetOrBuilder extends
      * .weaviate.v1.FilterReferenceCount count = 4;
      * @return The count.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getCount();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getCount();
     /**
      * .weaviate.v1.FilterReferenceCount count = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.TargetCase getTargetCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.TargetCase getTargetCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.FilterTarget}
@@ -16204,15 +16204,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder.class);
     }
 
     private int targetCase_ = 0;
@@ -16327,21 +16327,21 @@ public boolean hasSingleTarget() {
      * @return The singleTarget.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget() {
       if (targetCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
     }
     /**
      * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder() {
       if (targetCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
     }
 
     public static final int MULTI_TARGET_FIELD_NUMBER = 3;
@@ -16358,21 +16358,21 @@ public boolean hasMultiTarget() {
      * @return The multiTarget.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget() {
       if (targetCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
     }
     /**
      * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder() {
       if (targetCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
     }
 
     public static final int COUNT_FIELD_NUMBER = 4;
@@ -16389,21 +16389,21 @@ public boolean hasCount() {
      * @return The count.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getCount() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getCount() {
       if (targetCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
     }
     /**
      * .weaviate.v1.FilterReferenceCount count = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder() {
       if (targetCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
     }
 
     private byte memoizedIsInitialized = -1;
@@ -16424,13 +16424,13 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
         com.google.protobuf.GeneratedMessageV3.writeString(output, 1, target_);
       }
       if (targetCase_ == 2) {
-        output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_);
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_);
       }
       if (targetCase_ == 3) {
-        output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_);
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_);
       }
       if (targetCase_ == 4) {
-        output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_);
+        output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -16446,15 +16446,15 @@ public int getSerializedSize() {
       }
       if (targetCase_ == 2) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_);
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_);
       }
       if (targetCase_ == 3) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_);
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_);
       }
       if (targetCase_ == 4) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_);
+          .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSize = size;
@@ -16466,10 +16466,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget) obj;
 
       if (!getTargetCase().equals(other.getTargetCase())) return false;
       switch (targetCase_) {
@@ -16528,44 +16528,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -16573,26 +16573,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -16605,7 +16605,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -16626,21 +16626,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.FilterTarget)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTargetOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTargetOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.newBuilder()
       private Builder() {
 
       }
@@ -16671,17 +16671,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_FilterTarget_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -16689,19 +16689,19 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget build(
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget result) {
         int from_bitField0_ = bitField0_;
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget result) {
         result.targetCase_ = targetCase_;
         result.target_ = this.target_;
         if (targetCase_ == 2 &&
@@ -16752,16 +16752,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget.getDefaultInstance()) return this;
         switch (other.getTargetCase()) {
           case PROPERTY: {
             targetCase_ = 1;
@@ -16964,7 +16964,7 @@ public Builder setPropertyBytes(
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder> singleTargetBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder> singleTargetBuilder_;
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        * @return Whether the singleTarget field is set.
@@ -16978,23 +16978,23 @@ public boolean hasSingleTarget() {
        * @return The singleTarget.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget getSingleTarget() {
         if (singleTargetBuilder_ == null) {
           if (targetCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
         } else {
           if (targetCase_ == 2) {
             return singleTargetBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
-      public Builder setSingleTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget value) {
+      public Builder setSingleTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget value) {
         if (singleTargetBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -17011,7 +17011,7 @@ public Builder setSingleTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProto
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
       public Builder setSingleTarget(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder builderForValue) {
         if (singleTargetBuilder_ == null) {
           target_ = builderForValue.build();
           onChanged();
@@ -17024,11 +17024,11 @@ public Builder setSingleTarget(
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
-      public Builder mergeSingleTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget value) {
+      public Builder mergeSingleTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget value) {
         if (singleTargetBuilder_ == null) {
           if (targetCase_ == 2 &&
-              target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance()) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_)
+              target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance()) {
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_)
                 .mergeFrom(value).buildPartial();
           } else {
             target_ = value;
@@ -17066,36 +17066,36 @@ public Builder clearSingleTarget() {
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder getSingleTargetBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder getSingleTargetBuilder() {
         return getSingleTargetFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder getSingleTargetOrBuilder() {
         if ((targetCase_ == 2) && (singleTargetBuilder_ != null)) {
           return singleTargetBuilder_.getMessageOrBuilder();
         } else {
           if (targetCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceSingleTarget single_target = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder> 
           getSingleTargetFieldBuilder() {
         if (singleTargetBuilder_ == null) {
           if (!(targetCase_ == 2)) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.getDefaultInstance();
           }
           singleTargetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSingleTarget) target_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTargetOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceSingleTarget) target_,
                   getParentForChildren(),
                   isClean());
           target_ = null;
@@ -17106,7 +17106,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceSing
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder> multiTargetBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder> multiTargetBuilder_;
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        * @return Whether the multiTarget field is set.
@@ -17120,23 +17120,23 @@ public boolean hasMultiTarget() {
        * @return The multiTarget.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget getMultiTarget() {
         if (multiTargetBuilder_ == null) {
           if (targetCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
         } else {
           if (targetCase_ == 3) {
             return multiTargetBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
-      public Builder setMultiTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget value) {
+      public Builder setMultiTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget value) {
         if (multiTargetBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -17153,7 +17153,7 @@ public Builder setMultiTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoB
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
       public Builder setMultiTarget(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder builderForValue) {
         if (multiTargetBuilder_ == null) {
           target_ = builderForValue.build();
           onChanged();
@@ -17166,11 +17166,11 @@ public Builder setMultiTarget(
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
-      public Builder mergeMultiTarget(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget value) {
+      public Builder mergeMultiTarget(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget value) {
         if (multiTargetBuilder_ == null) {
           if (targetCase_ == 3 &&
-              target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance()) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_)
+              target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance()) {
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_)
                 .mergeFrom(value).buildPartial();
           } else {
             target_ = value;
@@ -17208,36 +17208,36 @@ public Builder clearMultiTarget() {
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder getMultiTargetBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder getMultiTargetBuilder() {
         return getMultiTargetFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder getMultiTargetOrBuilder() {
         if ((targetCase_ == 3) && (multiTargetBuilder_ != null)) {
           return multiTargetBuilder_.getMessageOrBuilder();
         } else {
           if (targetCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceMultiTarget multi_target = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder> 
           getMultiTargetFieldBuilder() {
         if (multiTargetBuilder_ == null) {
           if (!(targetCase_ == 3)) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.getDefaultInstance();
           }
           multiTargetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMultiTarget) target_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTargetOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceMultiTarget) target_,
                   getParentForChildren(),
                   isClean());
           target_ = null;
@@ -17248,7 +17248,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceMult
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder> countBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder> countBuilder_;
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        * @return Whether the count field is set.
@@ -17262,23 +17262,23 @@ public boolean hasCount() {
        * @return The count.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount getCount() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount getCount() {
         if (countBuilder_ == null) {
           if (targetCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
         } else {
           if (targetCase_ == 4) {
             return countBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
-      public Builder setCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount value) {
+      public Builder setCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount value) {
         if (countBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -17295,7 +17295,7 @@ public Builder setCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Fi
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
       public Builder setCount(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder builderForValue) {
         if (countBuilder_ == null) {
           target_ = builderForValue.build();
           onChanged();
@@ -17308,11 +17308,11 @@ public Builder setCount(
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
-      public Builder mergeCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount value) {
+      public Builder mergeCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount value) {
         if (countBuilder_ == null) {
           if (targetCase_ == 4 &&
-              target_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance()) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_)
+              target_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance()) {
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_)
                 .mergeFrom(value).buildPartial();
           } else {
             target_ = value;
@@ -17350,36 +17350,36 @@ public Builder clearCount() {
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder getCountBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder getCountBuilder() {
         return getCountFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder getCountOrBuilder() {
         if ((targetCase_ == 4) && (countBuilder_ != null)) {
           return countBuilder_.getMessageOrBuilder();
         } else {
           if (targetCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.FilterReferenceCount count = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder> 
           getCountFieldBuilder() {
         if (countBuilder_ == null) {
           if (!(targetCase_ == 4)) {
-            target_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
+            target_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.getDefaultInstance();
           }
           countBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCountOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterReferenceCount) target_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCountOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterReferenceCount) target_,
                   getParentForChildren(),
                   isClean());
           target_ = null;
@@ -17405,12 +17405,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.FilterTarget)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -17446,7 +17446,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FilterTarget getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FilterTarget getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -17498,15 +17498,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder.class);
     }
 
     public static final int LATITUDE_FIELD_NUMBER = 1;
@@ -17596,10 +17596,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) obj;
 
       if (java.lang.Float.floatToIntBits(getLatitude())
           != java.lang.Float.floatToIntBits(
@@ -17635,44 +17635,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17680,26 +17680,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinat
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17712,7 +17712,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinat
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -17733,21 +17733,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GeoCoordinatesFilter)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilterOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.newBuilder()
       private Builder() {
 
       }
@@ -17770,17 +17770,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_GeoCoordinatesFilter_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -17788,14 +17788,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilte
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.latitude_ = latitude_;
@@ -17842,16 +17842,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter.getDefaultInstance()) return this;
         if (other.getLatitude() != 0F) {
           setLatitude(other.getLatitude());
         }
@@ -18031,12 +18031,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GeoCoordinatesFilter)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18072,7 +18072,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.GeoCoordinatesFilter getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18101,7 +18101,7 @@ public interface VectorsOrBuilder extends
      *
      * uint64 index = 2 [deprecated = true];
      * @deprecated weaviate.v1.Vectors.index is deprecated.
-     *     See v1/base.proto;l=152
+     *     See v1/base.proto;l=151
      * @return The index.
      */
     @java.lang.Deprecated long getIndex();
@@ -18121,7 +18121,7 @@ public interface VectorsOrBuilder extends
      * .weaviate.v1.Vectors.VectorType type = 4;
      * @return The type.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType getType();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType getType();
   }
   /**
    * Protobuf type {@code weaviate.v1.Vectors}
@@ -18150,15 +18150,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder.class);
     }
 
     /**
@@ -18252,7 +18252,7 @@ public VectorType findValueByNumber(int number) {
       }
       public static final com.google.protobuf.Descriptors.EnumDescriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDescriptor().getEnumTypes().get(0);
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDescriptor().getEnumTypes().get(0);
       }
 
       private static final VectorType[] VALUES = values();
@@ -18326,7 +18326,7 @@ public java.lang.String getName() {
      *
      * uint64 index = 2 [deprecated = true];
      * @deprecated weaviate.v1.Vectors.index is deprecated.
-     *     See v1/base.proto;l=152
+     *     See v1/base.proto;l=151
      * @return The index.
      */
     @java.lang.Override
@@ -18358,9 +18358,9 @@ public com.google.protobuf.ByteString getVectorBytes() {
      * .weaviate.v1.Vectors.VectorType type = 4;
      * @return The type.
      */
-    @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType getType() {
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.forNumber(type_);
-      return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.UNRECOGNIZED : result;
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType getType() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.forNumber(type_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.UNRECOGNIZED : result;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -18386,7 +18386,7 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
       if (!vectorBytes_.isEmpty()) {
         output.writeBytes(3, vectorBytes_);
       }
-      if (type_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_UNSPECIFIED.getNumber()) {
+      if (type_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_UNSPECIFIED.getNumber()) {
         output.writeEnum(4, type_);
       }
       getUnknownFields().writeTo(output);
@@ -18409,7 +18409,7 @@ public int getSerializedSize() {
         size += com.google.protobuf.CodedOutputStream
           .computeBytesSize(3, vectorBytes_);
       }
-      if (type_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_UNSPECIFIED.getNumber()) {
+      if (type_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.VECTOR_TYPE_UNSPECIFIED.getNumber()) {
         size += com.google.protobuf.CodedOutputStream
           .computeEnumSize(4, type_);
       }
@@ -18423,10 +18423,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors) obj;
 
       if (!getName()
           .equals(other.getName())) return false;
@@ -18460,44 +18460,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -18505,26 +18505,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors pars
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -18537,7 +18537,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors pars
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -18558,21 +18558,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.Vectors)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.newBuilder()
       private Builder() {
 
       }
@@ -18596,17 +18596,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.internal_static_weaviate_v1_Vectors_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -18614,14 +18614,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors build() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.name_ = name_;
@@ -18671,16 +18671,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance()) return this;
         if (!other.getName().isEmpty()) {
           name_ = other.name_;
           bitField0_ |= 0x00000001;
@@ -18838,7 +18838,7 @@ public Builder setNameBytes(
        *
        * uint64 index = 2 [deprecated = true];
        * @deprecated weaviate.v1.Vectors.index is deprecated.
-       *     See v1/base.proto;l=152
+       *     See v1/base.proto;l=151
        * @return The index.
        */
       @java.lang.Override
@@ -18852,7 +18852,7 @@ public Builder setNameBytes(
        *
        * uint64 index = 2 [deprecated = true];
        * @deprecated weaviate.v1.Vectors.index is deprecated.
-       *     See v1/base.proto;l=152
+       *     See v1/base.proto;l=151
        * @param value The index to set.
        * @return This builder for chaining.
        */
@@ -18870,7 +18870,7 @@ public Builder setNameBytes(
        *
        * uint64 index = 2 [deprecated = true];
        * @deprecated weaviate.v1.Vectors.index is deprecated.
-       *     See v1/base.proto;l=152
+       *     See v1/base.proto;l=151
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearIndex() {
@@ -18936,16 +18936,16 @@ public Builder setTypeValue(int value) {
        * @return The type.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType getType() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.forNumber(type_);
-        return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType.UNRECOGNIZED : result;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType getType() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.forNumber(type_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType.UNRECOGNIZED : result;
       }
       /**
        * .weaviate.v1.Vectors.VectorType type = 4;
        * @param value The type to set.
        * @return This builder for chaining.
        */
-      public Builder setType(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.VectorType value) {
+      public Builder setType(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.VectorType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -18981,12 +18981,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.Vectors)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -19022,7 +19022,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -19201,10 +19201,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getDefaultI
       "yLevel\022!\n\035CONSISTENCY_LEVEL_UNSPECIFIED\020" +
       "\000\022\031\n\025CONSISTENCY_LEVEL_ONE\020\001\022\034\n\030CONSISTE" +
       "NCY_LEVEL_QUORUM\020\002\022\031\n\025CONSISTENCY_LEVEL_" +
-      "ALL\020\003Bn\n#io.weaviate.client.grpc.protoco" +
-      "l.v1B\021WeaviateProtoBaseZ4github.com/weav" +
-      "iate/weaviate/grpc/generated;protocolb\006p" +
-      "roto3"
+      "ALL\020\003BB\n-io.weaviate.client6.v1.internal" +
+      ".grpc.protocolB\021WeaviateProtoBaseb\006proto" +
+      "3"
     };
     descriptor = com.google.protobuf.Descriptors.FileDescriptor
       .internalBuildGeneratedFileFrom(descriptorData,
diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBaseSearch.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBaseSearch.java
similarity index 80%
rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBaseSearch.java
rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBaseSearch.java
index 1e60ca28a..18fd8c2cf 100644
--- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBaseSearch.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBaseSearch.java
@@ -1,7 +1,7 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: v1/base_search.proto
 
-package io.weaviate.client.grpc.protocol.v1;
+package io.weaviate.client6.v1.internal.grpc.protocol;
 
 public final class WeaviateProtoBaseSearch {
   private WeaviateProtoBaseSearch() {}
@@ -132,7 +132,7 @@ public CombinationMethod findValueByNumber(int number) {
     }
     public static final com.google.protobuf.Descriptors.EnumDescriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.getDescriptor().getEnumTypes().get(0);
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.getDescriptor().getEnumTypes().get(0);
     }
 
     private static final CombinationMethod[] VALUES = values();
@@ -205,15 +205,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder.class);
     }
 
     public static final int TARGET_FIELD_NUMBER = 1;
@@ -312,10 +312,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget) obj;
 
       if (!getTarget()
           .equals(other.getTarget())) return false;
@@ -343,44 +343,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -388,26 +388,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Weight
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -420,7 +420,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Weight
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -441,21 +441,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.WeightsForTarget)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.newBuilder()
       private Builder() {
 
       }
@@ -477,17 +477,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_WeightsForTarget_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -495,14 +495,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTar
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.target_ = target_;
@@ -546,16 +546,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance()) return this;
         if (!other.getTarget().isEmpty()) {
           target_ = other.target_;
           bitField0_ |= 0x00000001;
@@ -737,12 +737,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.WeightsForTarget)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -778,7 +778,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -822,17 +822,17 @@ public interface TargetsOrBuilder extends
      * .weaviate.v1.CombinationMethod combination = 2;
      * @return The combination.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod getCombination();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod getCombination();
 
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
-    java.util.List 
+    java.util.List 
         getWeightsForTargetsList();
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index);
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
@@ -840,12 +840,12 @@ public interface TargetsOrBuilder extends
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
-    java.util.List 
+    java.util.List 
         getWeightsForTargetsOrBuilderList();
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
         int index);
   }
   /**
@@ -876,15 +876,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder.class);
     }
 
     public static final int TARGET_VECTORS_FIELD_NUMBER = 1;
@@ -937,26 +937,26 @@ public java.lang.String getTargetVectors(int index) {
      * .weaviate.v1.CombinationMethod combination = 2;
      * @return The combination.
      */
-    @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod getCombination() {
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.forNumber(combination_);
-      return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.UNRECOGNIZED : result;
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod getCombination() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.forNumber(combination_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.UNRECOGNIZED : result;
     }
 
     public static final int WEIGHTS_FOR_TARGETS_FIELD_NUMBER = 4;
     @SuppressWarnings("serial")
-    private java.util.List weightsForTargets_;
+    private java.util.List weightsForTargets_;
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
     @java.lang.Override
-    public java.util.List getWeightsForTargetsList() {
+    public java.util.List getWeightsForTargetsList() {
       return weightsForTargets_;
     }
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getWeightsForTargetsOrBuilderList() {
       return weightsForTargets_;
     }
@@ -971,14 +971,14 @@ public int getWeightsForTargetsCount() {
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index) {
       return weightsForTargets_.get(index);
     }
     /**
      * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
         int index) {
       return weightsForTargets_.get(index);
     }
@@ -1000,7 +1000,7 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
       for (int i = 0; i < targetVectors_.size(); i++) {
         com.google.protobuf.GeneratedMessageV3.writeString(output, 1, targetVectors_.getRaw(i));
       }
-      if (combination_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_UNSPECIFIED.getNumber()) {
+      if (combination_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_UNSPECIFIED.getNumber()) {
         output.writeEnum(2, combination_);
       }
       for (int i = 0; i < weightsForTargets_.size(); i++) {
@@ -1023,7 +1023,7 @@ public int getSerializedSize() {
         size += dataSize;
         size += 1 * getTargetVectorsList().size();
       }
-      if (combination_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_UNSPECIFIED.getNumber()) {
+      if (combination_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.COMBINATION_METHOD_UNSPECIFIED.getNumber()) {
         size += com.google.protobuf.CodedOutputStream
           .computeEnumSize(2, combination_);
       }
@@ -1041,10 +1041,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets) obj;
 
       if (!getTargetVectorsList()
           .equals(other.getTargetVectorsList())) return false;
@@ -1077,44 +1077,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1122,26 +1122,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Target
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -1154,7 +1154,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Target
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -1175,21 +1175,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.Targets)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.newBuilder()
       private Builder() {
 
       }
@@ -1219,17 +1219,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Targets_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -1237,15 +1237,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets build
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets result) {
         if (weightsForTargetsBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0)) {
             weightsForTargets_ = java.util.Collections.unmodifiableList(weightsForTargets_);
@@ -1257,7 +1257,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           targetVectors_.makeImmutable();
@@ -1302,16 +1302,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) return this;
         if (!other.targetVectors_.isEmpty()) {
           if (targetVectors_.isEmpty()) {
             targetVectors_ = other.targetVectors_;
@@ -1389,9 +1389,9 @@ public Builder mergeFrom(
                 break;
               } // case 16
               case 34: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.parser(),
                         extensionRegistry);
                 if (weightsForTargetsBuilder_ == null) {
                   ensureWeightsForTargetsIsMutable();
@@ -1553,16 +1553,16 @@ public Builder setCombinationValue(int value) {
        * @return The combination.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod getCombination() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.forNumber(combination_);
-        return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod.UNRECOGNIZED : result;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod getCombination() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.forNumber(combination_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod.UNRECOGNIZED : result;
       }
       /**
        * .weaviate.v1.CombinationMethod combination = 2;
        * @param value The combination to set.
        * @return This builder for chaining.
        */
-      public Builder setCombination(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.CombinationMethod value) {
+      public Builder setCombination(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.CombinationMethod value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -1582,22 +1582,22 @@ public Builder clearCombination() {
         return this;
       }
 
-      private java.util.List weightsForTargets_ =
+      private java.util.List weightsForTargets_ =
         java.util.Collections.emptyList();
       private void ensureWeightsForTargetsIsMutable() {
         if (!((bitField0_ & 0x00000004) != 0)) {
-          weightsForTargets_ = new java.util.ArrayList(weightsForTargets_);
+          weightsForTargets_ = new java.util.ArrayList(weightsForTargets_);
           bitField0_ |= 0x00000004;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder> weightsForTargetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder> weightsForTargetsBuilder_;
 
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public java.util.List getWeightsForTargetsList() {
+      public java.util.List getWeightsForTargetsList() {
         if (weightsForTargetsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(weightsForTargets_);
         } else {
@@ -1617,7 +1617,7 @@ public int getWeightsForTargetsCount() {
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget getWeightsForTargets(int index) {
         if (weightsForTargetsBuilder_ == null) {
           return weightsForTargets_.get(index);
         } else {
@@ -1628,7 +1628,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTar
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder setWeightsForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget value) {
         if (weightsForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -1645,7 +1645,7 @@ public Builder setWeightsForTargets(
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder setWeightsForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
         if (weightsForTargetsBuilder_ == null) {
           ensureWeightsForTargetsIsMutable();
           weightsForTargets_.set(index, builderForValue.build());
@@ -1658,7 +1658,7 @@ public Builder setWeightsForTargets(
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public Builder addWeightsForTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget value) {
+      public Builder addWeightsForTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget value) {
         if (weightsForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -1675,7 +1675,7 @@ public Builder addWeightsForTargets(io.weaviate.client.grpc.protocol.v1.Weaviate
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder addWeightsForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget value) {
         if (weightsForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -1692,7 +1692,7 @@ public Builder addWeightsForTargets(
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder addWeightsForTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
         if (weightsForTargetsBuilder_ == null) {
           ensureWeightsForTargetsIsMutable();
           weightsForTargets_.add(builderForValue.build());
@@ -1706,7 +1706,7 @@ public Builder addWeightsForTargets(
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder addWeightsForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder builderForValue) {
         if (weightsForTargetsBuilder_ == null) {
           ensureWeightsForTargetsIsMutable();
           weightsForTargets_.add(index, builderForValue.build());
@@ -1720,7 +1720,7 @@ public Builder addWeightsForTargets(
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
       public Builder addAllWeightsForTargets(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (weightsForTargetsBuilder_ == null) {
           ensureWeightsForTargetsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -1760,14 +1760,14 @@ public Builder removeWeightsForTargets(int index) {
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder getWeightsForTargetsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder getWeightsForTargetsBuilder(
           int index) {
         return getWeightsForTargetsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder getWeightsForTargetsOrBuilder(
           int index) {
         if (weightsForTargetsBuilder_ == null) {
           return weightsForTargets_.get(index);  } else {
@@ -1777,7 +1777,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTar
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public java.util.List 
+      public java.util.List 
            getWeightsForTargetsOrBuilderList() {
         if (weightsForTargetsBuilder_ != null) {
           return weightsForTargetsBuilder_.getMessageOrBuilderList();
@@ -1788,31 +1788,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTar
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder addWeightsForTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder addWeightsForTargetsBuilder() {
         return getWeightsForTargetsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder addWeightsForTargetsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder addWeightsForTargetsBuilder(
           int index) {
         return getWeightsForTargetsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.WeightsForTarget weights_for_targets = 4;
        */
-      public java.util.List 
+      public java.util.List 
            getWeightsForTargetsBuilderList() {
         return getWeightsForTargetsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder> 
           getWeightsForTargetsFieldBuilder() {
         if (weightsForTargetsBuilder_ == null) {
           weightsForTargetsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.WeightsForTargetOrBuilder>(
                   weightsForTargets_,
                   ((bitField0_ & 0x00000004) != 0),
                   getParentForChildren(),
@@ -1838,12 +1838,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.Targets)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1879,7 +1879,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -1908,7 +1908,7 @@ public interface VectorForTargetOrBuilder extends
      *
      * bytes vector_bytes = 2 [deprecated = true];
      * @deprecated weaviate.v1.VectorForTarget.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=33
+     *     See v1/base_search.proto;l=32
      * @return The vectorBytes.
      */
     @java.lang.Deprecated com.google.protobuf.ByteString getVectorBytes();
@@ -1916,12 +1916,12 @@ public interface VectorForTargetOrBuilder extends
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
-    java.util.List 
+    java.util.List 
         getVectorsList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index);
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
@@ -1929,12 +1929,12 @@ public interface VectorForTargetOrBuilder extends
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
-    java.util.List 
+    java.util.List 
         getVectorsOrBuilderList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index);
   }
   /**
@@ -1964,15 +1964,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder.class);
     }
 
     public static final int NAME_FIELD_NUMBER = 1;
@@ -2023,7 +2023,7 @@ public java.lang.String getName() {
      *
      * bytes vector_bytes = 2 [deprecated = true];
      * @deprecated weaviate.v1.VectorForTarget.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=33
+     *     See v1/base_search.proto;l=32
      * @return The vectorBytes.
      */
     @java.lang.Override
@@ -2033,19 +2033,19 @@ public java.lang.String getName() {
 
     public static final int VECTORS_FIELD_NUMBER = 3;
     @SuppressWarnings("serial")
-    private java.util.List vectors_;
+    private java.util.List vectors_;
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
     @java.lang.Override
-    public java.util.List getVectorsList() {
+    public java.util.List getVectorsList() {
       return vectors_;
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getVectorsOrBuilderList() {
       return vectors_;
     }
@@ -2060,14 +2060,14 @@ public int getVectorsCount() {
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
       return vectors_.get(index);
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index) {
       return vectors_.get(index);
     }
@@ -2125,10 +2125,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget) obj;
 
       if (!getName()
           .equals(other.getName())) return false;
@@ -2160,44 +2160,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2205,26 +2205,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Vector
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2237,7 +2237,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Vector
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -2258,21 +2258,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.VectorForTarget)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.newBuilder()
       private Builder() {
 
       }
@@ -2301,17 +2301,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_VectorForTarget_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -2319,15 +2319,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarg
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget result) {
         if (vectorsBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0)) {
             vectors_ = java.util.Collections.unmodifiableList(vectors_);
@@ -2339,7 +2339,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.name_ = name_;
@@ -2383,16 +2383,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance()) return this;
         if (!other.getName().isEmpty()) {
           name_ = other.name_;
           bitField0_ |= 0x00000001;
@@ -2464,9 +2464,9 @@ public Builder mergeFrom(
                 break;
               } // case 18
               case 26: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.parser(),
                         extensionRegistry);
                 if (vectorsBuilder_ == null) {
                   ensureVectorsIsMutable();
@@ -2573,7 +2573,7 @@ public Builder setNameBytes(
        *
        * bytes vector_bytes = 2 [deprecated = true];
        * @deprecated weaviate.v1.VectorForTarget.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=33
+       *     See v1/base_search.proto;l=32
        * @return The vectorBytes.
        */
       @java.lang.Override
@@ -2587,7 +2587,7 @@ public Builder setNameBytes(
        *
        * bytes vector_bytes = 2 [deprecated = true];
        * @deprecated weaviate.v1.VectorForTarget.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=33
+       *     See v1/base_search.proto;l=32
        * @param value The vectorBytes to set.
        * @return This builder for chaining.
        */
@@ -2605,7 +2605,7 @@ public Builder setNameBytes(
        *
        * bytes vector_bytes = 2 [deprecated = true];
        * @deprecated weaviate.v1.VectorForTarget.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=33
+       *     See v1/base_search.proto;l=32
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearVectorBytes() {
@@ -2615,22 +2615,22 @@ public Builder setNameBytes(
         return this;
       }
 
-      private java.util.List vectors_ =
+      private java.util.List vectors_ =
         java.util.Collections.emptyList();
       private void ensureVectorsIsMutable() {
         if (!((bitField0_ & 0x00000004) != 0)) {
-          vectors_ = new java.util.ArrayList(vectors_);
+          vectors_ = new java.util.ArrayList(vectors_);
           bitField0_ |= 0x00000004;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
 
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public java.util.List getVectorsList() {
+      public java.util.List getVectorsList() {
         if (vectorsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(vectors_);
         } else {
@@ -2650,7 +2650,7 @@ public int getVectorsCount() {
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);
         } else {
@@ -2661,7 +2661,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2678,7 +2678,7 @@ public Builder setVectors(
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.set(index, builderForValue.build());
@@ -2691,7 +2691,7 @@ public Builder setVectors(
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+      public Builder addVectors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2708,7 +2708,7 @@ public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -2725,7 +2725,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder addVectors(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(builderForValue.build());
@@ -2739,7 +2739,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(index, builderForValue.build());
@@ -2753,7 +2753,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
       public Builder addAllVectors(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -2793,14 +2793,14 @@ public Builder removeVectors(int index) {
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
           int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);  } else {
@@ -2810,7 +2810,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsOrBuilderList() {
         if (vectorsBuilder_ != null) {
           return vectorsBuilder_.getMessageOrBuilderList();
@@ -2821,31 +2821,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
         return getVectorsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 3;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsBuilderList() {
         return getVectorsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> 
           getVectorsFieldBuilder() {
         if (vectorsBuilder_ == null) {
           vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder>(
                   vectors_,
                   ((bitField0_ & 0x00000004) != 0),
                   getParentForChildren(),
@@ -2871,12 +2871,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.VectorForTarget)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -2912,7 +2912,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -2931,7 +2931,7 @@ public interface SearchOperatorOptionsOrBuilder extends
      * .weaviate.v1.SearchOperatorOptions.Operator operator = 1;
      * @return The operator.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator();
 
     /**
      * optional int32 minimum_or_tokens_match = 2;
@@ -2969,15 +2969,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder.class);
     }
 
     /**
@@ -3071,7 +3071,7 @@ public Operator findValueByNumber(int number) {
       }
       public static final com.google.protobuf.Descriptors.EnumDescriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDescriptor().getEnumTypes().get(0);
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDescriptor().getEnumTypes().get(0);
       }
 
       private static final Operator[] VALUES = values();
@@ -3111,9 +3111,9 @@ private Operator(int value) {
      * .weaviate.v1.SearchOperatorOptions.Operator operator = 1;
      * @return The operator.
      */
-    @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator() {
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.forNumber(operator_);
-      return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.UNRECOGNIZED : result;
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.forNumber(operator_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.UNRECOGNIZED : result;
     }
 
     public static final int MINIMUM_OR_TOKENS_MATCH_FIELD_NUMBER = 2;
@@ -3149,7 +3149,7 @@ public final boolean isInitialized() {
     @java.lang.Override
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
-      if (operator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
+      if (operator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
         output.writeEnum(1, operator_);
       }
       if (((bitField0_ & 0x00000001) != 0)) {
@@ -3164,7 +3164,7 @@ public int getSerializedSize() {
       if (size != -1) return size;
 
       size = 0;
-      if (operator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
+      if (operator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.OPERATOR_UNSPECIFIED.getNumber()) {
         size += com.google.protobuf.CodedOutputStream
           .computeEnumSize(1, operator_);
       }
@@ -3182,10 +3182,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions) obj;
 
       if (operator_ != other.operator_) return false;
       if (hasMinimumOrTokensMatch() != other.hasMinimumOrTokensMatch()) return false;
@@ -3215,44 +3215,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -3260,26 +3260,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Search
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -3292,7 +3292,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Search
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -3313,21 +3313,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchOperatorOptions)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.newBuilder()
       private Builder() {
 
       }
@@ -3349,17 +3349,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_SearchOperatorOptions_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -3367,14 +3367,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperato
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.operator_ = operator_;
@@ -3421,16 +3421,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) return this;
         if (other.operator_ != 0) {
           setOperatorValue(other.getOperatorValue());
         }
@@ -3514,16 +3514,16 @@ public Builder setOperatorValue(int value) {
        * @return The operator.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.forNumber(operator_);
-        return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.UNRECOGNIZED : result;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator getOperator() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.forNumber(operator_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator.UNRECOGNIZED : result;
       }
       /**
        * .weaviate.v1.SearchOperatorOptions.Operator operator = 1;
        * @param value The operator to set.
        * @return This builder for chaining.
        */
-      public Builder setOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator value) {
+      public Builder setOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Operator value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -3599,12 +3599,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.SearchOperatorOptions)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3640,7 +3640,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3737,7 +3737,7 @@ public interface HybridOrBuilder extends
      * .weaviate.v1.Hybrid.FusionType fusion_type = 5;
      * @return The fusionType.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType();
 
     /**
      * 
@@ -3746,7 +3746,7 @@ public interface HybridOrBuilder extends
      *
      * bytes vector_bytes = 6 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=59
+     *     See v1/base_search.proto;l=60
      * @return The vectorBytes.
      */
     @java.lang.Deprecated com.google.protobuf.ByteString getVectorBytes();
@@ -3758,7 +3758,7 @@ public interface HybridOrBuilder extends
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -3770,7 +3770,7 @@ public interface HybridOrBuilder extends
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -3781,7 +3781,7 @@ public interface HybridOrBuilder extends
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -3793,7 +3793,7 @@ public interface HybridOrBuilder extends
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -3817,7 +3817,7 @@ public interface HybridOrBuilder extends
      * .weaviate.v1.NearTextSearch near_text = 8;
      * @return The nearText.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText();
     /**
      * 
      * targets in msg is ignored and should not be set for hybrid
@@ -3825,7 +3825,7 @@ public interface HybridOrBuilder extends
      *
      * .weaviate.v1.NearTextSearch near_text = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder();
 
     /**
      * 
@@ -3844,7 +3844,7 @@ public interface HybridOrBuilder extends
      * .weaviate.v1.NearVector near_vector = 9;
      * @return The nearVector.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector();
     /**
      * 
      * same as above. Use the target vector in the hybrid message
@@ -3852,7 +3852,7 @@ public interface HybridOrBuilder extends
      *
      * .weaviate.v1.NearVector near_vector = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder();
 
     /**
      * .weaviate.v1.Targets targets = 10;
@@ -3863,11 +3863,11 @@ public interface HybridOrBuilder extends
      * .weaviate.v1.Targets targets = 10;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 10;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
 
     /**
      * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
@@ -3878,11 +3878,11 @@ public interface HybridOrBuilder extends
      * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
      * @return The bm25SearchOperator.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator();
     /**
      * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder();
 
     /**
      * float vector_distance = 20;
@@ -3898,12 +3898,12 @@ public interface HybridOrBuilder extends
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
-    java.util.List 
+    java.util.List 
         getVectorsList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index);
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
@@ -3911,15 +3911,15 @@ public interface HybridOrBuilder extends
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
-    java.util.List 
+    java.util.List 
         getVectorsOrBuilderList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index);
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.ThresholdCase getThresholdCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.ThresholdCase getThresholdCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.Hybrid}
@@ -3954,15 +3954,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder.class);
     }
 
     /**
@@ -4056,7 +4056,7 @@ public FusionType findValueByNumber(int number) {
       }
       public static final com.google.protobuf.Descriptors.EnumDescriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDescriptor().getEnumTypes().get(0);
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDescriptor().getEnumTypes().get(0);
       }
 
       private static final FusionType[] VALUES = values();
@@ -4271,9 +4271,9 @@ public float getAlpha() {
      * .weaviate.v1.Hybrid.FusionType fusion_type = 5;
      * @return The fusionType.
      */
-    @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType() {
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.forNumber(fusionType_);
-      return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.UNRECOGNIZED : result;
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.forNumber(fusionType_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.UNRECOGNIZED : result;
     }
 
     public static final int VECTOR_BYTES_FIELD_NUMBER = 6;
@@ -4285,7 +4285,7 @@ public float getAlpha() {
      *
      * bytes vector_bytes = 6 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=59
+     *     See v1/base_search.proto;l=60
      * @return The vectorBytes.
      */
     @java.lang.Override
@@ -4304,7 +4304,7 @@ public float getAlpha() {
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -4318,7 +4318,7 @@ public float getAlpha() {
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -4331,7 +4331,7 @@ public float getAlpha() {
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -4345,7 +4345,7 @@ public float getAlpha() {
      *
      * repeated string target_vectors = 7 [deprecated = true];
      * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=60
+     *     See v1/base_search.proto;l=62
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -4355,7 +4355,7 @@ public float getAlpha() {
     }
 
     public static final int NEAR_TEXT_FIELD_NUMBER = 8;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch nearText_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch nearText_;
     /**
      * 
      * targets in msg is ignored and should not be set for hybrid
@@ -4377,8 +4377,8 @@ public boolean hasNearText() {
      * @return The nearText.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
-      return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
+      return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
     }
     /**
      * 
@@ -4388,12 +4388,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
      * .weaviate.v1.NearTextSearch near_text = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
-      return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
+      return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
     }
 
     public static final int NEAR_VECTOR_FIELD_NUMBER = 9;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector nearVector_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector nearVector_;
     /**
      * 
      * same as above. Use the target vector in the hybrid message
@@ -4415,8 +4415,8 @@ public boolean hasNearVector() {
      * @return The nearVector.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() {
-      return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() {
+      return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
     }
     /**
      * 
@@ -4426,12 +4426,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector ge
      * .weaviate.v1.NearVector near_vector = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
-      return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
+      return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
     }
 
     public static final int TARGETS_FIELD_NUMBER = 10;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 10;
      * @return Whether the targets field is set.
@@ -4445,19 +4445,19 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 10;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     public static final int BM25_SEARCH_OPERATOR_FIELD_NUMBER = 11;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions bm25SearchOperator_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions bm25SearchOperator_;
     /**
      * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
      * @return Whether the bm25SearchOperator field is set.
@@ -4471,15 +4471,15 @@ public boolean hasBm25SearchOperator() {
      * @return The bm25SearchOperator.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator() {
-      return bm25SearchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator() {
+      return bm25SearchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
     }
     /**
      * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder() {
-      return bm25SearchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder() {
+      return bm25SearchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
     }
 
     public static final int VECTOR_DISTANCE_FIELD_NUMBER = 20;
@@ -4505,19 +4505,19 @@ public float getVectorDistance() {
 
     public static final int VECTORS_FIELD_NUMBER = 21;
     @SuppressWarnings("serial")
-    private java.util.List vectors_;
+    private java.util.List vectors_;
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
     @java.lang.Override
-    public java.util.List getVectorsList() {
+    public java.util.List getVectorsList() {
       return vectors_;
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getVectorsOrBuilderList() {
       return vectors_;
     }
@@ -4532,14 +4532,14 @@ public int getVectorsCount() {
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
       return vectors_.get(index);
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 21;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index) {
       return vectors_.get(index);
     }
@@ -4575,7 +4575,7 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
       if (java.lang.Float.floatToRawIntBits(alpha_) != 0) {
         output.writeFloat(4, alpha_);
       }
-      if (fusionType_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_UNSPECIFIED.getNumber()) {
+      if (fusionType_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_UNSPECIFIED.getNumber()) {
         output.writeEnum(5, fusionType_);
       }
       if (!vectorBytes_.isEmpty()) {
@@ -4638,7 +4638,7 @@ public int getSerializedSize() {
         size += com.google.protobuf.CodedOutputStream
           .computeFloatSize(4, alpha_);
       }
-      if (fusionType_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_UNSPECIFIED.getNumber()) {
+      if (fusionType_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.FUSION_TYPE_UNSPECIFIED.getNumber()) {
         size += com.google.protobuf.CodedOutputStream
           .computeEnumSize(5, fusionType_);
       }
@@ -4689,10 +4689,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) obj;
 
       if (!getQuery()
           .equals(other.getQuery())) return false;
@@ -4806,44 +4806,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4851,26 +4851,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4883,7 +4883,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -4904,21 +4904,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.Hybrid)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.HybridOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -4986,17 +4986,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_Hybrid_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -5004,8 +5004,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid build(
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
@@ -5013,7 +5013,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid buildP
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid result) {
         if (vectorsBuilder_ == null) {
           if (((bitField0_ & 0x00001000) != 0)) {
             vectors_ = java.util.Collections.unmodifiableList(vectors_);
@@ -5025,7 +5025,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.query_ = query_;
@@ -5079,7 +5079,7 @@ private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
         result.bitField0_ |= to_bitField0_;
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid result) {
         result.thresholdCase_ = thresholdCase_;
         result.threshold_ = this.threshold_;
       }
@@ -5118,16 +5118,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) return this;
         if (!other.getQuery().isEmpty()) {
           query_ = other.query_;
           bitField0_ |= 0x00000001;
@@ -5329,9 +5329,9 @@ public Builder mergeFrom(
                 break;
               } // case 165
               case 170: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.parser(),
                         extensionRegistry);
                 if (vectorsBuilder_ == null) {
                   ensureVectorsIsMutable();
@@ -5744,16 +5744,16 @@ public Builder setFusionTypeValue(int value) {
        * @return The fusionType.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.forNumber(fusionType_);
-        return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType.UNRECOGNIZED : result;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType getFusionType() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.forNumber(fusionType_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType.UNRECOGNIZED : result;
       }
       /**
        * .weaviate.v1.Hybrid.FusionType fusion_type = 5;
        * @param value The fusionType to set.
        * @return This builder for chaining.
        */
-      public Builder setFusionType(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid.FusionType value) {
+      public Builder setFusionType(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.FusionType value) {
         if (value == null) {
           throw new NullPointerException();
         }
@@ -5781,7 +5781,7 @@ public Builder clearFusionType() {
        *
        * bytes vector_bytes = 6 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=59
+       *     See v1/base_search.proto;l=60
        * @return The vectorBytes.
        */
       @java.lang.Override
@@ -5795,7 +5795,7 @@ public Builder clearFusionType() {
        *
        * bytes vector_bytes = 6 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=59
+       *     See v1/base_search.proto;l=60
        * @param value The vectorBytes to set.
        * @return This builder for chaining.
        */
@@ -5813,7 +5813,7 @@ public Builder clearFusionType() {
        *
        * bytes vector_bytes = 6 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=59
+       *     See v1/base_search.proto;l=60
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearVectorBytes() {
@@ -5838,7 +5838,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -5853,7 +5853,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -5866,7 +5866,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -5880,7 +5880,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -5895,7 +5895,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -5916,7 +5916,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -5936,7 +5936,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -5956,7 +5956,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -5973,7 +5973,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 7 [deprecated = true];
        * @deprecated weaviate.v1.Hybrid.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=60
+       *     See v1/base_search.proto;l=62
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -5988,9 +5988,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch nearText_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch nearText_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_;
       /**
        * 
        * targets in msg is ignored and should not be set for hybrid
@@ -6010,9 +6010,9 @@ public boolean hasNearText() {
        * .weaviate.v1.NearTextSearch near_text = 8;
        * @return The nearText.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() {
         if (nearTextBuilder_ == null) {
-          return nearText_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
+          return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
         } else {
           return nearTextBuilder_.getMessage();
         }
@@ -6024,7 +6024,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
        *
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
-      public Builder setNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) {
+      public Builder setNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) {
         if (nearTextBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6045,7 +6045,7 @@ public Builder setNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
       public Builder setNearText(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) {
         if (nearTextBuilder_ == null) {
           nearText_ = builderForValue.build();
         } else {
@@ -6062,11 +6062,11 @@ public Builder setNearText(
        *
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
-      public Builder mergeNearText(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch value) {
+      public Builder mergeNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) {
         if (nearTextBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             nearText_ != null &&
-            nearText_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) {
+            nearText_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) {
             getNearTextBuilder().mergeFrom(value);
           } else {
             nearText_ = value;
@@ -6104,7 +6104,7 @@ public Builder clearNearText() {
        *
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getNearTextFieldBuilder().getBuilder();
@@ -6116,12 +6116,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
        *
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() {
         if (nearTextBuilder_ != null) {
           return nearTextBuilder_.getMessageOrBuilder();
         } else {
           return nearText_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_;
         }
       }
       /**
@@ -6132,11 +6132,11 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
        * .weaviate.v1.NearTextSearch near_text = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> 
           getNearTextFieldBuilder() {
         if (nearTextBuilder_ == null) {
           nearTextBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>(
                   getNearText(),
                   getParentForChildren(),
                   isClean());
@@ -6145,9 +6145,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
         return nearTextBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector nearVector_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector nearVector_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_;
       /**
        * 
        * same as above. Use the target vector in the hybrid message
@@ -6167,9 +6167,9 @@ public boolean hasNearVector() {
        * .weaviate.v1.NearVector near_vector = 9;
        * @return The nearVector.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getNearVector() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() {
         if (nearVectorBuilder_ == null) {
-          return nearVector_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
+          return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
         } else {
           return nearVectorBuilder_.getMessage();
         }
@@ -6181,7 +6181,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector ge
        *
        * .weaviate.v1.NearVector near_vector = 9;
        */
-      public Builder setNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) {
+      public Builder setNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) {
         if (nearVectorBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6202,7 +6202,7 @@ public Builder setNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBa
        * .weaviate.v1.NearVector near_vector = 9;
        */
       public Builder setNearVector(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) {
         if (nearVectorBuilder_ == null) {
           nearVector_ = builderForValue.build();
         } else {
@@ -6219,11 +6219,11 @@ public Builder setNearVector(
        *
        * .weaviate.v1.NearVector near_vector = 9;
        */
-      public Builder mergeNearVector(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector value) {
+      public Builder mergeNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) {
         if (nearVectorBuilder_ == null) {
           if (((bitField0_ & 0x00000100) != 0) &&
             nearVector_ != null &&
-            nearVector_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) {
+            nearVector_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) {
             getNearVectorBuilder().mergeFrom(value);
           } else {
             nearVector_ = value;
@@ -6261,7 +6261,7 @@ public Builder clearNearVector() {
        *
        * .weaviate.v1.NearVector near_vector = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() {
         bitField0_ |= 0x00000100;
         onChanged();
         return getNearVectorFieldBuilder().getBuilder();
@@ -6273,12 +6273,12 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Bu
        *
        * .weaviate.v1.NearVector near_vector = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() {
         if (nearVectorBuilder_ != null) {
           return nearVectorBuilder_.getMessageOrBuilder();
         } else {
           return nearVector_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_;
         }
       }
       /**
@@ -6289,11 +6289,11 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrB
        * .weaviate.v1.NearVector near_vector = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> 
           getNearVectorFieldBuilder() {
         if (nearVectorBuilder_ == null) {
           nearVectorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder>(
                   getNearVector(),
                   getParentForChildren(),
                   isClean());
@@ -6302,9 +6302,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrB
         return nearVectorBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 10;
        * @return Whether the targets field is set.
@@ -6316,9 +6316,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 10;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -6326,7 +6326,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 10;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6343,7 +6343,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 10;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -6356,11 +6356,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 10;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000200) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -6390,7 +6390,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 10;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000200;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -6398,23 +6398,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 10;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 10;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -6423,9 +6423,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuil
         return targetsBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions bm25SearchOperator_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions bm25SearchOperator_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> bm25SearchOperatorBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> bm25SearchOperatorBuilder_;
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        * @return Whether the bm25SearchOperator field is set.
@@ -6437,9 +6437,9 @@ public boolean hasBm25SearchOperator() {
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        * @return The bm25SearchOperator.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getBm25SearchOperator() {
         if (bm25SearchOperatorBuilder_ == null) {
-          return bm25SearchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
+          return bm25SearchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
         } else {
           return bm25SearchOperatorBuilder_.getMessage();
         }
@@ -6447,7 +6447,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperato
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
-      public Builder setBm25SearchOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
+      public Builder setBm25SearchOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
         if (bm25SearchOperatorBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6464,7 +6464,7 @@ public Builder setBm25SearchOperator(io.weaviate.client.grpc.protocol.v1.Weaviat
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
       public Builder setBm25SearchOperator(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder builderForValue) {
         if (bm25SearchOperatorBuilder_ == null) {
           bm25SearchOperator_ = builderForValue.build();
         } else {
@@ -6477,11 +6477,11 @@ public Builder setBm25SearchOperator(
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
-      public Builder mergeBm25SearchOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
+      public Builder mergeBm25SearchOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
         if (bm25SearchOperatorBuilder_ == null) {
           if (((bitField0_ & 0x00000400) != 0) &&
             bm25SearchOperator_ != null &&
-            bm25SearchOperator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) {
+            bm25SearchOperator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) {
             getBm25SearchOperatorBuilder().mergeFrom(value);
           } else {
             bm25SearchOperator_ = value;
@@ -6511,7 +6511,7 @@ public Builder clearBm25SearchOperator() {
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder getBm25SearchOperatorBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder getBm25SearchOperatorBuilder() {
         bitField0_ |= 0x00000400;
         onChanged();
         return getBm25SearchOperatorFieldBuilder().getBuilder();
@@ -6519,23 +6519,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperato
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getBm25SearchOperatorOrBuilder() {
         if (bm25SearchOperatorBuilder_ != null) {
           return bm25SearchOperatorBuilder_.getMessageOrBuilder();
         } else {
           return bm25SearchOperator_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : bm25SearchOperator_;
         }
       }
       /**
        * optional .weaviate.v1.SearchOperatorOptions bm25_search_operator = 11;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> 
           getBm25SearchOperatorFieldBuilder() {
         if (bm25SearchOperatorBuilder_ == null) {
           bm25SearchOperatorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder>(
                   getBm25SearchOperator(),
                   getParentForChildren(),
                   isClean());
@@ -6586,22 +6586,22 @@ public Builder clearVectorDistance() {
         return this;
       }
 
-      private java.util.List vectors_ =
+      private java.util.List vectors_ =
         java.util.Collections.emptyList();
       private void ensureVectorsIsMutable() {
         if (!((bitField0_ & 0x00001000) != 0)) {
-          vectors_ = new java.util.ArrayList(vectors_);
+          vectors_ = new java.util.ArrayList(vectors_);
           bitField0_ |= 0x00001000;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
 
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public java.util.List getVectorsList() {
+      public java.util.List getVectorsList() {
         if (vectorsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(vectors_);
         } else {
@@ -6621,7 +6621,7 @@ public int getVectorsCount() {
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);
         } else {
@@ -6632,7 +6632,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6649,7 +6649,7 @@ public Builder setVectors(
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.set(index, builderForValue.build());
@@ -6662,7 +6662,7 @@ public Builder setVectors(
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+      public Builder addVectors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6679,7 +6679,7 @@ public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6696,7 +6696,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder addVectors(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(builderForValue.build());
@@ -6710,7 +6710,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(index, builderForValue.build());
@@ -6724,7 +6724,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
       public Builder addAllVectors(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -6764,14 +6764,14 @@ public Builder removeVectors(int index) {
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
           int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);  } else {
@@ -6781,7 +6781,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsOrBuilderList() {
         if (vectorsBuilder_ != null) {
           return vectorsBuilder_.getMessageOrBuilderList();
@@ -6792,31 +6792,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
         return getVectorsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 21;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsBuilderList() {
         return getVectorsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> 
           getVectorsFieldBuilder() {
         if (vectorsBuilder_ == null) {
           vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder>(
                   vectors_,
                   ((bitField0_ & 0x00001000) != 0),
                   getParentForChildren(),
@@ -6842,12 +6842,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.Hybrid)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -6883,7 +6883,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Hybrid getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -6900,7 +6900,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @return A list containing the vector.
      */
     @java.lang.Deprecated java.util.List getVectorList();
@@ -6911,7 +6911,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @return The count of vector.
      */
     @java.lang.Deprecated int getVectorCount();
@@ -6922,7 +6922,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @param index The index of the element to return.
      * @return The vector at the given index.
      */
@@ -6957,7 +6957,7 @@ public interface NearVectorOrBuilder extends
      *
      * bytes vector_bytes = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=79
+     *     See v1/base_search.proto;l=83
      * @return The vectorBytes.
      */
     @java.lang.Deprecated com.google.protobuf.ByteString getVectorBytes();
@@ -6969,7 +6969,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -6981,7 +6981,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -6992,7 +6992,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -7004,7 +7004,7 @@ public interface NearVectorOrBuilder extends
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -7020,11 +7020,11 @@ public interface NearVectorOrBuilder extends
      * .weaviate.v1.Targets targets = 6;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
 
     /**
      * 
@@ -7083,12 +7083,12 @@ com.google.protobuf.ByteString getVectorPerTargetOrDefault(
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
-    java.util.List 
+    java.util.List 
         getVectorForTargetsList();
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index);
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
@@ -7096,23 +7096,23 @@ com.google.protobuf.ByteString getVectorPerTargetOrDefault(
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
-    java.util.List 
+    java.util.List 
         getVectorForTargetsOrBuilderList();
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
         int index);
 
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
-    java.util.List 
+    java.util.List 
         getVectorsList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index);
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
@@ -7120,12 +7120,12 @@ io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBui
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
-    java.util.List 
+    java.util.List 
         getVectorsOrBuilderList();
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index);
   }
   /**
@@ -7158,7 +7158,7 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
     }
 
     @SuppressWarnings({"rawtypes"})
@@ -7176,9 +7176,9 @@ protected com.google.protobuf.MapField internalGetMapField(
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder.class);
     }
 
     private int bitField0_;
@@ -7193,7 +7193,7 @@ protected com.google.protobuf.MapField internalGetMapField(
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @return A list containing the vector.
      */
     @java.lang.Override
@@ -7208,7 +7208,7 @@ protected com.google.protobuf.MapField internalGetMapField(
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @return The count of vector.
      */
     @java.lang.Deprecated public int getVectorCount() {
@@ -7221,7 +7221,7 @@ protected com.google.protobuf.MapField internalGetMapField(
      *
      * repeated float vector = 1 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector is deprecated.
-     *     See v1/base_search.proto;l=76
+     *     See v1/base_search.proto;l=79
      * @param index The index of the element to return.
      * @return The vector at the given index.
      */
@@ -7277,7 +7277,7 @@ public double getDistance() {
      *
      * bytes vector_bytes = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.vector_bytes is deprecated.
-     *     See v1/base_search.proto;l=79
+     *     See v1/base_search.proto;l=83
      * @return The vectorBytes.
      */
     @java.lang.Override
@@ -7296,7 +7296,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -7310,7 +7310,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -7323,7 +7323,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -7337,7 +7337,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 5 [deprecated = true];
      * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=80
+     *     See v1/base_search.proto;l=85
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -7347,7 +7347,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 6;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 6;
      * @return Whether the targets field is set.
@@ -7361,15 +7361,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     public static final int VECTOR_PER_TARGET_FIELD_NUMBER = 7;
@@ -7378,7 +7378,7 @@ private static final class VectorPerTargetDefaultEntryHolder {
           java.lang.String, com.google.protobuf.ByteString> defaultEntry =
               com.google.protobuf.MapEntry
               .newDefaultInstance(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_VectorPerTargetEntry_descriptor, 
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_VectorPerTargetEntry_descriptor, 
                   com.google.protobuf.WireFormat.FieldType.STRING,
                   "",
                   com.google.protobuf.WireFormat.FieldType.BYTES,
@@ -7469,19 +7469,19 @@ com.google.protobuf.ByteString getVectorPerTargetOrDefault(
 
     public static final int VECTOR_FOR_TARGETS_FIELD_NUMBER = 8;
     @SuppressWarnings("serial")
-    private java.util.List vectorForTargets_;
+    private java.util.List vectorForTargets_;
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
     @java.lang.Override
-    public java.util.List getVectorForTargetsList() {
+    public java.util.List getVectorForTargetsList() {
       return vectorForTargets_;
     }
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getVectorForTargetsOrBuilderList() {
       return vectorForTargets_;
     }
@@ -7496,33 +7496,33 @@ public int getVectorForTargetsCount() {
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index) {
       return vectorForTargets_.get(index);
     }
     /**
      * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
         int index) {
       return vectorForTargets_.get(index);
     }
 
     public static final int VECTORS_FIELD_NUMBER = 9;
     @SuppressWarnings("serial")
-    private java.util.List vectors_;
+    private java.util.List vectors_;
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
     @java.lang.Override
-    public java.util.List getVectorsList() {
+    public java.util.List getVectorsList() {
       return vectors_;
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getVectorsOrBuilderList() {
       return vectors_;
     }
@@ -7537,14 +7537,14 @@ public int getVectorsCount() {
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
       return vectors_.get(index);
     }
     /**
      * repeated .weaviate.v1.Vectors vectors = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
         int index) {
       return vectors_.get(index);
     }
@@ -7670,10 +7670,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) obj;
 
       if (!getVectorList()
           .equals(other.getVectorList())) return false;
@@ -7756,44 +7756,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7801,26 +7801,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVe
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7833,7 +7833,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVe
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -7854,10 +7854,10 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearVector)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVectorOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
       }
 
       @SuppressWarnings({"rawtypes"})
@@ -7885,12 +7885,12 @@ protected com.google.protobuf.MapField internalGetMutableMapField(
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -7944,17 +7944,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVector_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -7962,15 +7962,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector bu
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector result) {
         if (vectorForTargetsBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0)) {
             vectorForTargets_ = java.util.Collections.unmodifiableList(vectorForTargets_);
@@ -7991,7 +7991,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           vector_.makeImmutable();
@@ -8060,16 +8060,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) return this;
         if (!other.vector_.isEmpty()) {
           if (vector_.isEmpty()) {
             vector_ = other.vector_;
@@ -8239,9 +8239,9 @@ public Builder mergeFrom(
                 break;
               } // case 58
               case 66: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.parser(),
                         extensionRegistry);
                 if (vectorForTargetsBuilder_ == null) {
                   ensureVectorForTargetsIsMutable();
@@ -8252,9 +8252,9 @@ public Builder mergeFrom(
                 break;
               } // case 66
               case 74: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.parser(),
                         extensionRegistry);
                 if (vectorsBuilder_ == null) {
                   ensureVectorsIsMutable();
@@ -8301,7 +8301,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @return A list containing the vector.
        */
       @java.lang.Deprecated public java.util.List
@@ -8316,7 +8316,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @return The count of vector.
        */
       @java.lang.Deprecated public int getVectorCount() {
@@ -8329,7 +8329,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @param index The index of the element to return.
        * @return The vector at the given index.
        */
@@ -8343,7 +8343,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @param index The index to set the value at.
        * @param value The vector to set.
        * @return This builder for chaining.
@@ -8364,7 +8364,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @param value The vector to add.
        * @return This builder for chaining.
        */
@@ -8383,7 +8383,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @param values The vector to add.
        * @return This builder for chaining.
        */
@@ -8403,7 +8403,7 @@ private void ensureVectorIsMutable(int capacity) {
        *
        * repeated float vector = 1 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector is deprecated.
-       *     See v1/base_search.proto;l=76
+       *     See v1/base_search.proto;l=79
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearVector() {
@@ -8501,7 +8501,7 @@ public Builder clearDistance() {
        *
        * bytes vector_bytes = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=79
+       *     See v1/base_search.proto;l=83
        * @return The vectorBytes.
        */
       @java.lang.Override
@@ -8515,7 +8515,7 @@ public Builder clearDistance() {
        *
        * bytes vector_bytes = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=79
+       *     See v1/base_search.proto;l=83
        * @param value The vectorBytes to set.
        * @return This builder for chaining.
        */
@@ -8533,7 +8533,7 @@ public Builder clearDistance() {
        *
        * bytes vector_bytes = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.vector_bytes is deprecated.
-       *     See v1/base_search.proto;l=79
+       *     See v1/base_search.proto;l=83
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearVectorBytes() {
@@ -8558,7 +8558,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -8573,7 +8573,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -8586,7 +8586,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -8600,7 +8600,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -8615,7 +8615,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -8636,7 +8636,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -8656,7 +8656,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -8676,7 +8676,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -8693,7 +8693,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 5 [deprecated = true];
        * @deprecated weaviate.v1.NearVector.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=80
+       *     See v1/base_search.proto;l=85
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -8708,9 +8708,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 6;
        * @return Whether the targets field is set.
@@ -8722,9 +8722,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 6;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -8732,7 +8732,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 6;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -8749,7 +8749,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 6;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -8762,11 +8762,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 6;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000020) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -8796,7 +8796,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000020;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -8804,23 +8804,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 6;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -8984,22 +8984,22 @@ com.google.protobuf.ByteString getVectorPerTargetOrDefault(
         return this;
       }
 
-      private java.util.List vectorForTargets_ =
+      private java.util.List vectorForTargets_ =
         java.util.Collections.emptyList();
       private void ensureVectorForTargetsIsMutable() {
         if (!((bitField0_ & 0x00000080) != 0)) {
-          vectorForTargets_ = new java.util.ArrayList(vectorForTargets_);
+          vectorForTargets_ = new java.util.ArrayList(vectorForTargets_);
           bitField0_ |= 0x00000080;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder> vectorForTargetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder> vectorForTargetsBuilder_;
 
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public java.util.List getVectorForTargetsList() {
+      public java.util.List getVectorForTargetsList() {
         if (vectorForTargetsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(vectorForTargets_);
         } else {
@@ -9019,7 +9019,7 @@ public int getVectorForTargetsCount() {
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget getVectorForTargets(int index) {
         if (vectorForTargetsBuilder_ == null) {
           return vectorForTargets_.get(index);
         } else {
@@ -9030,7 +9030,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarg
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder setVectorForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget value) {
         if (vectorForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9047,7 +9047,7 @@ public Builder setVectorForTargets(
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder setVectorForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
         if (vectorForTargetsBuilder_ == null) {
           ensureVectorForTargetsIsMutable();
           vectorForTargets_.set(index, builderForValue.build());
@@ -9060,7 +9060,7 @@ public Builder setVectorForTargets(
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public Builder addVectorForTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget value) {
+      public Builder addVectorForTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget value) {
         if (vectorForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9077,7 +9077,7 @@ public Builder addVectorForTargets(io.weaviate.client.grpc.protocol.v1.WeaviateP
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder addVectorForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget value) {
         if (vectorForTargetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9094,7 +9094,7 @@ public Builder addVectorForTargets(
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder addVectorForTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
         if (vectorForTargetsBuilder_ == null) {
           ensureVectorForTargetsIsMutable();
           vectorForTargets_.add(builderForValue.build());
@@ -9108,7 +9108,7 @@ public Builder addVectorForTargets(
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder addVectorForTargets(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder builderForValue) {
         if (vectorForTargetsBuilder_ == null) {
           ensureVectorForTargetsIsMutable();
           vectorForTargets_.add(index, builderForValue.build());
@@ -9122,7 +9122,7 @@ public Builder addVectorForTargets(
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
       public Builder addAllVectorForTargets(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (vectorForTargetsBuilder_ == null) {
           ensureVectorForTargetsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -9162,14 +9162,14 @@ public Builder removeVectorForTargets(int index) {
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder getVectorForTargetsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder getVectorForTargetsBuilder(
           int index) {
         return getVectorForTargetsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder getVectorForTargetsOrBuilder(
           int index) {
         if (vectorForTargetsBuilder_ == null) {
           return vectorForTargets_.get(index);  } else {
@@ -9179,7 +9179,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarg
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorForTargetsOrBuilderList() {
         if (vectorForTargetsBuilder_ != null) {
           return vectorForTargetsBuilder_.getMessageOrBuilderList();
@@ -9190,31 +9190,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarg
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder addVectorForTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder addVectorForTargetsBuilder() {
         return getVectorForTargetsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder addVectorForTargetsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder addVectorForTargetsBuilder(
           int index) {
         return getVectorForTargetsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.VectorForTarget vector_for_targets = 8;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorForTargetsBuilderList() {
         return getVectorForTargetsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder> 
           getVectorForTargetsFieldBuilder() {
         if (vectorForTargetsBuilder_ == null) {
           vectorForTargetsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTargetOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTarget.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.VectorForTargetOrBuilder>(
                   vectorForTargets_,
                   ((bitField0_ & 0x00000080) != 0),
                   getParentForChildren(),
@@ -9224,22 +9224,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.VectorForTarg
         return vectorForTargetsBuilder_;
       }
 
-      private java.util.List vectors_ =
+      private java.util.List vectors_ =
         java.util.Collections.emptyList();
       private void ensureVectorsIsMutable() {
         if (!((bitField0_ & 0x00000100) != 0)) {
-          vectors_ = new java.util.ArrayList(vectors_);
+          vectors_ = new java.util.ArrayList(vectors_);
           bitField0_ |= 0x00000100;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_;
 
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public java.util.List getVectorsList() {
+      public java.util.List getVectorsList() {
         if (vectorsBuilder_ == null) {
           return java.util.Collections.unmodifiableList(vectors_);
         } else {
@@ -9259,7 +9259,7 @@ public int getVectorsCount() {
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);
         } else {
@@ -9270,7 +9270,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors getVectors(
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9287,7 +9287,7 @@ public Builder setVectors(
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder setVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.set(index, builderForValue.build());
@@ -9300,7 +9300,7 @@ public Builder setVectors(
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+      public Builder addVectors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9317,7 +9317,7 @@ public Builder addVectors(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) {
         if (vectorsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -9334,7 +9334,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder addVectors(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(builderForValue.build());
@@ -9348,7 +9348,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder addVectors(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           vectors_.add(index, builderForValue.build());
@@ -9362,7 +9362,7 @@ public Builder addVectors(
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
       public Builder addAllVectors(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (vectorsBuilder_ == null) {
           ensureVectorsIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -9402,14 +9402,14 @@ public Builder removeVectors(int index) {
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder getVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder(
           int index) {
         if (vectorsBuilder_ == null) {
           return vectors_.get(index);  } else {
@@ -9419,7 +9419,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsOrBuilderList() {
         if (vectorsBuilder_ != null) {
           return vectorsBuilder_.getMessageOrBuilderList();
@@ -9430,31 +9430,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder ge
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() {
         return getVectorsFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder(
           int index) {
         return getVectorsFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.Vectors vectors = 9;
        */
-      public java.util.List 
+      public java.util.List 
            getVectorsBuilderList() {
         return getVectorsFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> 
           getVectorsFieldBuilder() {
         if (vectorsBuilder_ == null) {
           vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Vectors.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.VectorsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder>(
                   vectors_,
                   ((bitField0_ & 0x00000100) != 0),
                   getParentForChildren(),
@@ -9480,12 +9480,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearVector)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9521,7 +9521,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVector getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9572,7 +9572,7 @@ public interface NearObjectOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -9584,7 +9584,7 @@ public interface NearObjectOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -9595,7 +9595,7 @@ public interface NearObjectOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -9607,7 +9607,7 @@ public interface NearObjectOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -9623,11 +9623,11 @@ public interface NearObjectOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearObject}
@@ -9656,15 +9656,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder.class);
     }
 
     private int bitField0_;
@@ -9756,7 +9756,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -9770,7 +9770,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -9783,7 +9783,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -9797,7 +9797,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=91
+     *     See v1/base_search.proto;l=98
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -9807,7 +9807,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -9821,15 +9821,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -9903,10 +9903,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) obj;
 
       if (!getId()
           .equals(other.getId())) return false;
@@ -9965,44 +9965,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10010,26 +10010,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearOb
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10042,7 +10042,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearOb
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -10063,21 +10063,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearObject)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObjectOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -10113,17 +10113,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearObject_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -10131,14 +10131,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject bu
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.id_ = id_;
@@ -10199,16 +10199,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) return this;
         if (!other.getId().isEmpty()) {
           id_ = other.id_;
           bitField0_ |= 0x00000001;
@@ -10471,7 +10471,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -10486,7 +10486,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -10499,7 +10499,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -10513,7 +10513,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -10528,7 +10528,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -10549,7 +10549,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -10569,7 +10569,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -10589,7 +10589,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -10606,7 +10606,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearObject.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=91
+       *     See v1/base_search.proto;l=98
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -10621,9 +10621,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -10635,9 +10635,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -10645,7 +10645,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -10662,7 +10662,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -10675,11 +10675,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -10709,7 +10709,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -10717,23 +10717,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -10758,12 +10758,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearObject)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -10799,7 +10799,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearObject getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -10881,11 +10881,11 @@ public interface NearTextSearchOrBuilder extends
      * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
      * @return The moveTo.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo();
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder();
 
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
@@ -10896,11 +10896,11 @@ public interface NearTextSearchOrBuilder extends
      * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
      * @return The moveAway.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway();
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder();
 
     /**
      * 
@@ -10909,7 +10909,7 @@ public interface NearTextSearchOrBuilder extends
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -10921,7 +10921,7 @@ public interface NearTextSearchOrBuilder extends
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -10932,7 +10932,7 @@ public interface NearTextSearchOrBuilder extends
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -10944,7 +10944,7 @@ public interface NearTextSearchOrBuilder extends
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -10960,11 +10960,11 @@ public interface NearTextSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 7;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearTextSearch}
@@ -10994,15 +10994,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder.class);
     }
 
     public interface MoveOrBuilder extends
@@ -11093,15 +11093,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder.class);
       }
 
       public static final int FORCE_FIELD_NUMBER = 1;
@@ -11251,10 +11251,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move) obj;
 
         if (java.lang.Float.floatToIntBits(getForce())
             != java.lang.Float.floatToIntBits(
@@ -11290,44 +11290,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -11335,26 +11335,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTe
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -11367,7 +11367,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTe
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -11388,21 +11388,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.NearTextSearch.Move)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.newBuilder()
         private Builder() {
 
         }
@@ -11427,17 +11427,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_Move_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -11445,14 +11445,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.force_ = force_;
@@ -11501,16 +11501,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) return this;
           if (other.getForce() != 0F) {
             setForce(other.getForce());
           }
@@ -11864,12 +11864,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.NearTextSearch.Move)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -11905,7 +11905,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -12004,7 +12004,7 @@ public double getDistance() {
     }
 
     public static final int MOVE_TO_FIELD_NUMBER = 4;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move moveTo_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move moveTo_;
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
      * @return Whether the moveTo field is set.
@@ -12018,19 +12018,19 @@ public boolean hasMoveTo() {
      * @return The moveTo.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo() {
-      return moveTo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo() {
+      return moveTo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
     }
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder() {
-      return moveTo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder() {
+      return moveTo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
     }
 
     public static final int MOVE_AWAY_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move moveAway_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move moveAway_;
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
      * @return Whether the moveAway field is set.
@@ -12044,15 +12044,15 @@ public boolean hasMoveAway() {
      * @return The moveAway.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway() {
-      return moveAway_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway() {
+      return moveAway_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
     }
     /**
      * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder() {
-      return moveAway_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder() {
+      return moveAway_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
     }
 
     public static final int TARGET_VECTORS_FIELD_NUMBER = 6;
@@ -12066,7 +12066,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -12080,7 +12080,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -12093,7 +12093,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -12107,7 +12107,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
      *
      * repeated string target_vectors = 6 [deprecated = true];
      * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=108
+     *     See v1/base_search.proto;l=116
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -12117,7 +12117,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
     }
 
     public static final int TARGETS_FIELD_NUMBER = 7;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 7;
      * @return Whether the targets field is set.
@@ -12131,15 +12131,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -12232,10 +12232,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) obj;
 
       if (!getQueryList()
           .equals(other.getQueryList())) return false;
@@ -12314,44 +12314,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -12359,26 +12359,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTe
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -12391,7 +12391,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTe
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -12412,21 +12412,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearTextSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -12475,17 +12475,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearTextSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -12493,14 +12493,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           query_.makeImmutable();
@@ -12574,16 +12574,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) return this;
         if (!other.query_.isEmpty()) {
           if (query_.isEmpty()) {
             query_ = other.query_;
@@ -12932,9 +12932,9 @@ public Builder clearDistance() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move moveTo_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move moveTo_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> moveToBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> moveToBuilder_;
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        * @return Whether the moveTo field is set.
@@ -12946,9 +12946,9 @@ public boolean hasMoveTo() {
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        * @return The moveTo.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveTo() {
         if (moveToBuilder_ == null) {
-          return moveTo_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
+          return moveTo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
         } else {
           return moveToBuilder_.getMessage();
         }
@@ -12956,7 +12956,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
-      public Builder setMoveTo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
+      public Builder setMoveTo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
         if (moveToBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -12973,7 +12973,7 @@ public Builder setMoveTo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSe
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
       public Builder setMoveTo(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder builderForValue) {
         if (moveToBuilder_ == null) {
           moveTo_ = builderForValue.build();
         } else {
@@ -12986,11 +12986,11 @@ public Builder setMoveTo(
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
-      public Builder mergeMoveTo(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
+      public Builder mergeMoveTo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
         if (moveToBuilder_ == null) {
           if (((bitField0_ & 0x00000008) != 0) &&
             moveTo_ != null &&
-            moveTo_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) {
+            moveTo_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) {
             getMoveToBuilder().mergeFrom(value);
           } else {
             moveTo_ = value;
@@ -13020,7 +13020,7 @@ public Builder clearMoveTo() {
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder getMoveToBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder getMoveToBuilder() {
         bitField0_ |= 0x00000008;
         onChanged();
         return getMoveToFieldBuilder().getBuilder();
@@ -13028,23 +13028,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveToOrBuilder() {
         if (moveToBuilder_ != null) {
           return moveToBuilder_.getMessageOrBuilder();
         } else {
           return moveTo_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveTo_;
         }
       }
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_to = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> 
           getMoveToFieldBuilder() {
         if (moveToBuilder_ == null) {
           moveToBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder>(
                   getMoveTo(),
                   getParentForChildren(),
                   isClean());
@@ -13053,9 +13053,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
         return moveToBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move moveAway_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move moveAway_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> moveAwayBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> moveAwayBuilder_;
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        * @return Whether the moveAway field is set.
@@ -13067,9 +13067,9 @@ public boolean hasMoveAway() {
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        * @return The moveAway.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move getMoveAway() {
         if (moveAwayBuilder_ == null) {
-          return moveAway_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
+          return moveAway_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
         } else {
           return moveAwayBuilder_.getMessage();
         }
@@ -13077,7 +13077,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
-      public Builder setMoveAway(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
+      public Builder setMoveAway(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
         if (moveAwayBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13094,7 +13094,7 @@ public Builder setMoveAway(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
       public Builder setMoveAway(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder builderForValue) {
         if (moveAwayBuilder_ == null) {
           moveAway_ = builderForValue.build();
         } else {
@@ -13107,11 +13107,11 @@ public Builder setMoveAway(
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
-      public Builder mergeMoveAway(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
+      public Builder mergeMoveAway(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move value) {
         if (moveAwayBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             moveAway_ != null &&
-            moveAway_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) {
+            moveAway_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance()) {
             getMoveAwayBuilder().mergeFrom(value);
           } else {
             moveAway_ = value;
@@ -13141,7 +13141,7 @@ public Builder clearMoveAway() {
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder getMoveAwayBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder getMoveAwayBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getMoveAwayFieldBuilder().getBuilder();
@@ -13149,23 +13149,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearc
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder getMoveAwayOrBuilder() {
         if (moveAwayBuilder_ != null) {
           return moveAwayBuilder_.getMessageOrBuilder();
         } else {
           return moveAway_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.getDefaultInstance() : moveAway_;
         }
       }
       /**
        * optional .weaviate.v1.NearTextSearch.Move move_away = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder> 
           getMoveAwayFieldBuilder() {
         if (moveAwayBuilder_ == null) {
           moveAwayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Move.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.MoveOrBuilder>(
                   getMoveAway(),
                   getParentForChildren(),
                   isClean());
@@ -13189,7 +13189,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -13204,7 +13204,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -13217,7 +13217,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -13231,7 +13231,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -13246,7 +13246,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -13267,7 +13267,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -13287,7 +13287,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -13307,7 +13307,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -13324,7 +13324,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 6 [deprecated = true];
        * @deprecated weaviate.v1.NearTextSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=108
+       *     See v1/base_search.proto;l=116
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -13339,9 +13339,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 7;
        * @return Whether the targets field is set.
@@ -13353,9 +13353,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 7;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -13363,7 +13363,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 7;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13380,7 +13380,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 7;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -13393,11 +13393,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 7;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000040) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -13427,7 +13427,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000040;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -13435,23 +13435,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 7;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -13476,12 +13476,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearTextSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13517,7 +13517,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13568,7 +13568,7 @@ public interface NearImageSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -13580,7 +13580,7 @@ public interface NearImageSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -13591,7 +13591,7 @@ public interface NearImageSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -13603,7 +13603,7 @@ public interface NearImageSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -13619,11 +13619,11 @@ public interface NearImageSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearImageSearch}
@@ -13652,15 +13652,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -13752,7 +13752,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -13766,7 +13766,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -13779,7 +13779,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -13793,7 +13793,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=116
+     *     See v1/base_search.proto;l=125
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -13803,7 +13803,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -13817,15 +13817,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -13899,10 +13899,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) obj;
 
       if (!getImage()
           .equals(other.getImage())) return false;
@@ -13961,44 +13961,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14006,26 +14006,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIm
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14038,7 +14038,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIm
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -14059,21 +14059,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearImageSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -14109,17 +14109,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearImageSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -14127,14 +14127,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSear
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.image_ = image_;
@@ -14195,16 +14195,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) return this;
         if (!other.getImage().isEmpty()) {
           image_ = other.image_;
           bitField0_ |= 0x00000001;
@@ -14467,7 +14467,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -14482,7 +14482,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -14495,7 +14495,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -14509,7 +14509,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -14524,7 +14524,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -14545,7 +14545,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -14565,7 +14565,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -14585,7 +14585,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -14602,7 +14602,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearImageSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=116
+       *     See v1/base_search.proto;l=125
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -14617,9 +14617,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -14631,9 +14631,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -14641,7 +14641,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -14658,7 +14658,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -14671,11 +14671,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -14705,7 +14705,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -14713,23 +14713,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -14754,12 +14754,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearImageSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14795,7 +14795,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14846,7 +14846,7 @@ public interface NearAudioSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -14858,7 +14858,7 @@ public interface NearAudioSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -14869,7 +14869,7 @@ public interface NearAudioSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -14881,7 +14881,7 @@ public interface NearAudioSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -14897,11 +14897,11 @@ public interface NearAudioSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearAudioSearch}
@@ -14930,15 +14930,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -15030,7 +15030,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -15044,7 +15044,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -15057,7 +15057,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -15071,7 +15071,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=124
+     *     See v1/base_search.proto;l=134
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -15081,7 +15081,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -15095,15 +15095,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -15177,10 +15177,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) obj;
 
       if (!getAudio()
           .equals(other.getAudio())) return false;
@@ -15239,44 +15239,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15284,26 +15284,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAu
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15316,7 +15316,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAu
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -15337,21 +15337,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearAudioSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -15387,17 +15387,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearAudioSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -15405,14 +15405,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSear
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.audio_ = audio_;
@@ -15473,16 +15473,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) return this;
         if (!other.getAudio().isEmpty()) {
           audio_ = other.audio_;
           bitField0_ |= 0x00000001;
@@ -15745,7 +15745,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -15760,7 +15760,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -15773,7 +15773,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -15787,7 +15787,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -15802,7 +15802,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -15823,7 +15823,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -15843,7 +15843,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -15863,7 +15863,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -15880,7 +15880,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearAudioSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=124
+       *     See v1/base_search.proto;l=134
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -15895,9 +15895,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -15909,9 +15909,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -15919,7 +15919,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -15936,7 +15936,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -15949,11 +15949,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -15983,7 +15983,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -15991,23 +15991,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -16032,12 +16032,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearAudioSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16073,7 +16073,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16124,7 +16124,7 @@ public interface NearVideoSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -16136,7 +16136,7 @@ public interface NearVideoSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -16147,7 +16147,7 @@ public interface NearVideoSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -16159,7 +16159,7 @@ public interface NearVideoSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -16175,11 +16175,11 @@ public interface NearVideoSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearVideoSearch}
@@ -16208,15 +16208,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -16308,7 +16308,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -16322,7 +16322,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -16335,7 +16335,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -16349,7 +16349,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=132
+     *     See v1/base_search.proto;l=143
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -16359,7 +16359,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -16373,15 +16373,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -16455,10 +16455,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) obj;
 
       if (!getVideo()
           .equals(other.getVideo())) return false;
@@ -16517,44 +16517,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -16562,26 +16562,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVi
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -16594,7 +16594,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVi
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -16615,21 +16615,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearVideoSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -16665,17 +16665,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearVideoSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -16683,14 +16683,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSear
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.video_ = video_;
@@ -16751,16 +16751,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) return this;
         if (!other.getVideo().isEmpty()) {
           video_ = other.video_;
           bitField0_ |= 0x00000001;
@@ -17023,7 +17023,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -17038,7 +17038,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -17051,7 +17051,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -17065,7 +17065,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -17080,7 +17080,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -17101,7 +17101,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -17121,7 +17121,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -17141,7 +17141,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -17158,7 +17158,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearVideoSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=132
+       *     See v1/base_search.proto;l=143
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -17173,9 +17173,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -17187,9 +17187,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -17197,7 +17197,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -17214,7 +17214,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -17227,11 +17227,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -17261,7 +17261,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -17269,23 +17269,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -17310,12 +17310,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearVideoSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -17351,7 +17351,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -17402,7 +17402,7 @@ public interface NearDepthSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -17414,7 +17414,7 @@ public interface NearDepthSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -17425,7 +17425,7 @@ public interface NearDepthSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -17437,7 +17437,7 @@ public interface NearDepthSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -17453,11 +17453,11 @@ public interface NearDepthSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearDepthSearch}
@@ -17486,15 +17486,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -17586,7 +17586,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -17600,7 +17600,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -17613,7 +17613,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -17627,7 +17627,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=140
+     *     See v1/base_search.proto;l=152
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -17637,7 +17637,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -17651,15 +17651,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -17733,10 +17733,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) obj;
 
       if (!getDepth()
           .equals(other.getDepth())) return false;
@@ -17795,44 +17795,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17840,26 +17840,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDe
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17872,7 +17872,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDe
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -17893,21 +17893,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearDepthSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -17943,17 +17943,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearDepthSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -17961,14 +17961,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSear
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.depth_ = depth_;
@@ -18029,16 +18029,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) return this;
         if (!other.getDepth().isEmpty()) {
           depth_ = other.depth_;
           bitField0_ |= 0x00000001;
@@ -18301,7 +18301,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -18316,7 +18316,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -18329,7 +18329,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -18343,7 +18343,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -18358,7 +18358,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -18379,7 +18379,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -18399,7 +18399,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -18419,7 +18419,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -18436,7 +18436,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearDepthSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=140
+       *     See v1/base_search.proto;l=152
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -18451,9 +18451,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -18465,9 +18465,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -18475,7 +18475,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -18492,7 +18492,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -18505,11 +18505,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -18539,7 +18539,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -18547,23 +18547,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -18588,12 +18588,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearDepthSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18629,7 +18629,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18680,7 +18680,7 @@ public interface NearThermalSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -18692,7 +18692,7 @@ public interface NearThermalSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -18703,7 +18703,7 @@ public interface NearThermalSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -18715,7 +18715,7 @@ public interface NearThermalSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -18731,11 +18731,11 @@ public interface NearThermalSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearThermalSearch}
@@ -18764,15 +18764,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -18864,7 +18864,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -18878,7 +18878,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -18891,7 +18891,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -18905,7 +18905,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=148
+     *     See v1/base_search.proto;l=161
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -18915,7 +18915,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -18929,15 +18929,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -19011,10 +19011,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) obj;
 
       if (!getThermal()
           .equals(other.getThermal())) return false;
@@ -19073,44 +19073,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -19118,26 +19118,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTh
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -19150,7 +19150,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearTh
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -19171,21 +19171,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearThermalSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -19221,17 +19221,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearThermalSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -19239,14 +19239,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSe
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.thermal_ = thermal_;
@@ -19307,16 +19307,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) return this;
         if (!other.getThermal().isEmpty()) {
           thermal_ = other.thermal_;
           bitField0_ |= 0x00000001;
@@ -19579,7 +19579,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -19594,7 +19594,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -19607,7 +19607,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -19621,7 +19621,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -19636,7 +19636,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -19657,7 +19657,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -19677,7 +19677,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -19697,7 +19697,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -19714,7 +19714,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearThermalSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=148
+       *     See v1/base_search.proto;l=161
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -19729,9 +19729,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -19743,9 +19743,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -19753,7 +19753,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -19770,7 +19770,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -19783,11 +19783,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -19817,7 +19817,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -19825,23 +19825,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -19866,12 +19866,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearThermalSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -19907,7 +19907,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -19958,7 +19958,7 @@ public interface NearIMUSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated java.util.List
@@ -19970,7 +19970,7 @@ public interface NearIMUSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated int getTargetVectorsCount();
@@ -19981,7 +19981,7 @@ public interface NearIMUSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -19993,7 +19993,7 @@ public interface NearIMUSearchOrBuilder extends
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -20009,11 +20009,11 @@ public interface NearIMUSearchOrBuilder extends
      * .weaviate.v1.Targets targets = 5;
      * @return The targets.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets();
     /**
      * .weaviate.v1.Targets targets = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.NearIMUSearch}
@@ -20042,15 +20042,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder.class);
     }
 
     private int bitField0_;
@@ -20142,7 +20142,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @return A list containing the targetVectors.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -20156,7 +20156,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @return The count of targetVectors.
      */
     @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -20169,7 +20169,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @param index The index of the element to return.
      * @return The targetVectors at the given index.
      */
@@ -20183,7 +20183,7 @@ public double getDistance() {
      *
      * repeated string target_vectors = 4 [deprecated = true];
      * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-     *     See v1/base_search.proto;l=156
+     *     See v1/base_search.proto;l=170
      * @param index The index of the value to return.
      * @return The bytes of the targetVectors at the given index.
      */
@@ -20193,7 +20193,7 @@ public double getDistance() {
     }
 
     public static final int TARGETS_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
     /**
      * .weaviate.v1.Targets targets = 5;
      * @return Whether the targets field is set.
@@ -20207,15 +20207,15 @@ public boolean hasTargets() {
      * @return The targets.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
     /**
      * .weaviate.v1.Targets targets = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
-      return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -20289,10 +20289,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) obj;
 
       if (!getImu()
           .equals(other.getImu())) return false;
@@ -20351,44 +20351,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -20396,26 +20396,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIM
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -20428,7 +20428,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIM
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -20449,21 +20449,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.NearIMUSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -20499,17 +20499,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_NearIMUSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -20517,14 +20517,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.imu_ = imu_;
@@ -20585,16 +20585,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) return this;
         if (!other.getImu().isEmpty()) {
           imu_ = other.imu_;
           bitField0_ |= 0x00000001;
@@ -20857,7 +20857,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @return A list containing the targetVectors.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -20872,7 +20872,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @return The count of targetVectors.
        */
       @java.lang.Deprecated public int getTargetVectorsCount() {
@@ -20885,7 +20885,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param index The index of the element to return.
        * @return The targetVectors at the given index.
        */
@@ -20899,7 +20899,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param index The index of the value to return.
        * @return The bytes of the targetVectors at the given index.
        */
@@ -20914,7 +20914,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param index The index to set the value at.
        * @param value The targetVectors to set.
        * @return This builder for chaining.
@@ -20935,7 +20935,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param value The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -20955,7 +20955,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param values The targetVectors to add.
        * @return This builder for chaining.
        */
@@ -20975,7 +20975,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearTargetVectors() {
@@ -20992,7 +20992,7 @@ private void ensureTargetVectorsIsMutable() {
        *
        * repeated string target_vectors = 4 [deprecated = true];
        * @deprecated weaviate.v1.NearIMUSearch.target_vectors is deprecated.
-       *     See v1/base_search.proto;l=156
+       *     See v1/base_search.proto;l=170
        * @param value The bytes of the targetVectors to add.
        * @return This builder for chaining.
        */
@@ -21007,9 +21007,9 @@ private void ensureTargetVectorsIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets targets_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets targets_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> targetsBuilder_;
       /**
        * .weaviate.v1.Targets targets = 5;
        * @return Whether the targets field is set.
@@ -21021,9 +21021,9 @@ public boolean hasTargets() {
        * .weaviate.v1.Targets targets = 5;
        * @return The targets.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTargets() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets getTargets() {
         if (targetsBuilder_ == null) {
-          return targets_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+          return targets_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         } else {
           return targetsBuilder_.getMessage();
         }
@@ -21031,7 +21031,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets getTa
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder setTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -21048,7 +21048,7 @@ public Builder setTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseS
        * .weaviate.v1.Targets targets = 5;
        */
       public Builder setTargets(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder builderForValue) {
         if (targetsBuilder_ == null) {
           targets_ = builderForValue.build();
         } else {
@@ -21061,11 +21061,11 @@ public Builder setTargets(
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public Builder mergeTargets(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets value) {
+      public Builder mergeTargets(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets value) {
         if (targetsBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             targets_ != null &&
-            targets_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
+            targets_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance()) {
             getTargetsBuilder().mergeFrom(value);
           } else {
             targets_ = value;
@@ -21095,7 +21095,7 @@ public Builder clearTargets() {
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder getTargetsBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getTargetsFieldBuilder().getBuilder();
@@ -21103,23 +21103,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Build
       /**
        * .weaviate.v1.Targets targets = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder getTargetsOrBuilder() {
         if (targetsBuilder_ != null) {
           return targetsBuilder_.getMessageOrBuilder();
         } else {
           return targets_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.getDefaultInstance() : targets_;
         }
       }
       /**
        * .weaviate.v1.Targets targets = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder> 
           getTargetsFieldBuilder() {
         if (targetsBuilder_ == null) {
           targetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.TargetsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Targets.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.TargetsOrBuilder>(
                   getTargets(),
                   getParentForChildren(),
                   isClean());
@@ -21144,12 +21144,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.NearIMUSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -21185,7 +21185,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -21241,11 +21241,11 @@ public interface BM25OrBuilder extends
      * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
      * @return The searchOperator.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator();
     /**
      * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.BM25}
@@ -21274,15 +21274,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder.class);
     }
 
     private int bitField0_;
@@ -21363,7 +21363,7 @@ public java.lang.String getProperties(int index) {
     }
 
     public static final int SEARCH_OPERATOR_FIELD_NUMBER = 3;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions searchOperator_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions searchOperator_;
     /**
      * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
      * @return Whether the searchOperator field is set.
@@ -21377,15 +21377,15 @@ public boolean hasSearchOperator() {
      * @return The searchOperator.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator() {
-      return searchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator() {
+      return searchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
     }
     /**
      * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder() {
-      return searchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder() {
+      return searchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -21445,10 +21445,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25) obj;
 
       if (!getQuery()
           .equals(other.getQuery())) return false;
@@ -21485,44 +21485,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -21530,26 +21530,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 p
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -21562,7 +21562,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 p
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -21583,21 +21583,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.BM25)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25OrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -21631,17 +21631,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.internal_static_weaviate_v1_BM25_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -21649,14 +21649,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 build()
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.query_ = query_;
@@ -21709,16 +21709,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance()) return this;
         if (!other.getQuery().isEmpty()) {
           query_ = other.query_;
           bitField0_ |= 0x00000001;
@@ -21981,9 +21981,9 @@ public Builder addPropertiesBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions searchOperator_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions searchOperator_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> searchOperatorBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> searchOperatorBuilder_;
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        * @return Whether the searchOperator field is set.
@@ -21995,9 +21995,9 @@ public boolean hasSearchOperator() {
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        * @return The searchOperator.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions getSearchOperator() {
         if (searchOperatorBuilder_ == null) {
-          return searchOperator_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
+          return searchOperator_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
         } else {
           return searchOperatorBuilder_.getMessage();
         }
@@ -22005,7 +22005,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperato
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
-      public Builder setSearchOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
+      public Builder setSearchOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
         if (searchOperatorBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -22022,7 +22022,7 @@ public Builder setSearchOperator(io.weaviate.client.grpc.protocol.v1.WeaviatePro
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
       public Builder setSearchOperator(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder builderForValue) {
         if (searchOperatorBuilder_ == null) {
           searchOperator_ = builderForValue.build();
         } else {
@@ -22035,11 +22035,11 @@ public Builder setSearchOperator(
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
-      public Builder mergeSearchOperator(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
+      public Builder mergeSearchOperator(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions value) {
         if (searchOperatorBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0) &&
             searchOperator_ != null &&
-            searchOperator_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) {
+            searchOperator_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance()) {
             getSearchOperatorBuilder().mergeFrom(value);
           } else {
             searchOperator_ = value;
@@ -22069,7 +22069,7 @@ public Builder clearSearchOperator() {
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder getSearchOperatorBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder getSearchOperatorBuilder() {
         bitField0_ |= 0x00000004;
         onChanged();
         return getSearchOperatorFieldBuilder().getBuilder();
@@ -22077,23 +22077,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperato
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder getSearchOperatorOrBuilder() {
         if (searchOperatorBuilder_ != null) {
           return searchOperatorBuilder_.getMessageOrBuilder();
         } else {
           return searchOperator_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.getDefaultInstance() : searchOperator_;
         }
       }
       /**
        * optional .weaviate.v1.SearchOperatorOptions search_operator = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder> 
           getSearchOperatorFieldBuilder() {
         if (searchOperatorBuilder_ == null) {
           searchOperatorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptions.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.SearchOperatorOptionsOrBuilder>(
                   getSearchOperator(),
                   getParentForChildren(),
                   isClean());
@@ -22118,12 +22118,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.BM25)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -22159,7 +22159,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -22348,15 +22348,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getDefau
       "_METHOD_TYPE_MIN\020\002\022#\n\037COMBINATION_METHOD" +
       "_TYPE_AVERAGE\020\003\022*\n&COMBINATION_METHOD_TY" +
       "PE_RELATIVE_SCORE\020\004\022\"\n\036COMBINATION_METHO" +
-      "D_TYPE_MANUAL\020\005Bt\n#io.weaviate.client.gr" +
-      "pc.protocol.v1B\027WeaviateProtoBaseSearchZ" +
-      "4github.com/weaviate/weaviate/grpc/gener" +
-      "ated;protocolb\006proto3"
+      "D_TYPE_MANUAL\020\005BH\n-io.weaviate.client6.v" +
+      "1.internal.grpc.protocolB\027WeaviateProtoB" +
+      "aseSearchb\006proto3"
     };
     descriptor = com.google.protobuf.Descriptors.FileDescriptor
       .internalBuildGeneratedFileFrom(descriptorData,
         new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(),
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(),
         });
     internal_static_weaviate_v1_WeightsForTarget_descriptor =
       getDescriptor().getMessageTypes().get(0);
@@ -22460,7 +22459,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBaseSearch.BM25 getDefau
       com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
         internal_static_weaviate_v1_BM25_descriptor,
         new java.lang.String[] { "Query", "Properties", "SearchOperator", "SearchOperator", });
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor();
   }
 
   // @@protoc_insertion_point(outer_class_scope)
diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatch.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatch.java
new file mode 100644
index 000000000..9048e740a
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatch.java
@@ -0,0 +1,22686 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: v1/batch.proto
+
+package io.weaviate.client6.v1.internal.grpc.protocol;
+
+public final class WeaviateProtoBatch {
+  private WeaviateProtoBatch() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  public interface BatchObjectsRequestOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsRequest)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    java.util.List 
+        getObjectsList();
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getObjects(int index);
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    int getObjectsCount();
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    java.util.List 
+        getObjectsOrBuilderList();
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder(
+        int index);
+
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return Whether the consistencyLevel field is set.
+     */
+    boolean hasConsistencyLevel();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    int getConsistencyLevelValue();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The consistencyLevel.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchObjectsRequest}
+   */
+  public static final class BatchObjectsRequest extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsRequest)
+      BatchObjectsRequestOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchObjectsRequest.newBuilder() to construct.
+    private BatchObjectsRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchObjectsRequest() {
+      objects_ = java.util.Collections.emptyList();
+      consistencyLevel_ = 0;
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchObjectsRequest();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.Builder.class);
+    }
+
+    private int bitField0_;
+    public static final int OBJECTS_FIELD_NUMBER = 1;
+    @SuppressWarnings("serial")
+    private java.util.List objects_;
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    @java.lang.Override
+    public java.util.List getObjectsList() {
+      return objects_;
+    }
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    @java.lang.Override
+    public java.util.List 
+        getObjectsOrBuilderList() {
+      return objects_;
+    }
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    @java.lang.Override
+    public int getObjectsCount() {
+      return objects_.size();
+    }
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getObjects(int index) {
+      return objects_.get(index);
+    }
+    /**
+     * repeated .weaviate.v1.BatchObject objects = 1;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder(
+        int index) {
+      return objects_.get(index);
+    }
+
+    public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 2;
+    private int consistencyLevel_ = 0;
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return Whether the consistencyLevel field is set.
+     */
+    @java.lang.Override public boolean hasConsistencyLevel() {
+      return ((bitField0_ & 0x00000001) != 0);
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    @java.lang.Override public int getConsistencyLevelValue() {
+      return consistencyLevel_;
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The consistencyLevel.
+     */
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      for (int i = 0; i < objects_.size(); i++) {
+        output.writeMessage(1, objects_.get(i));
+      }
+      if (((bitField0_ & 0x00000001) != 0)) {
+        output.writeEnum(2, consistencyLevel_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      for (int i = 0; i < objects_.size(); i++) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, objects_.get(i));
+      }
+      if (((bitField0_ & 0x00000001) != 0)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeEnumSize(2, consistencyLevel_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest) obj;
+
+      if (!getObjectsList()
+          .equals(other.getObjectsList())) return false;
+      if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false;
+      if (hasConsistencyLevel()) {
+        if (consistencyLevel_ != other.consistencyLevel_) return false;
+      }
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      if (getObjectsCount() > 0) {
+        hash = (37 * hash) + OBJECTS_FIELD_NUMBER;
+        hash = (53 * hash) + getObjectsList().hashCode();
+      }
+      if (hasConsistencyLevel()) {
+        hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER;
+        hash = (53 * hash) + consistencyLevel_;
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchObjectsRequest}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsRequest)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequestOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        if (objectsBuilder_ == null) {
+          objects_ = java.util.Collections.emptyList();
+        } else {
+          objects_ = null;
+          objectsBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000001);
+        consistencyLevel_ = 0;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsRequest_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest(this);
+        buildPartialRepeatedFields(result);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest result) {
+        if (objectsBuilder_ == null) {
+          if (((bitField0_ & 0x00000001) != 0)) {
+            objects_ = java.util.Collections.unmodifiableList(objects_);
+            bitField0_ = (bitField0_ & ~0x00000001);
+          }
+          result.objects_ = objects_;
+        } else {
+          result.objects_ = objectsBuilder_.build();
+        }
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest result) {
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000002) != 0)) {
+          result.consistencyLevel_ = consistencyLevel_;
+          to_bitField0_ |= 0x00000001;
+        }
+        result.bitField0_ |= to_bitField0_;
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest.getDefaultInstance()) return this;
+        if (objectsBuilder_ == null) {
+          if (!other.objects_.isEmpty()) {
+            if (objects_.isEmpty()) {
+              objects_ = other.objects_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+            } else {
+              ensureObjectsIsMutable();
+              objects_.addAll(other.objects_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.objects_.isEmpty()) {
+            if (objectsBuilder_.isEmpty()) {
+              objectsBuilder_.dispose();
+              objectsBuilder_ = null;
+              objects_ = other.objects_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+              objectsBuilder_ = 
+                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                   getObjectsFieldBuilder() : null;
+            } else {
+              objectsBuilder_.addAllMessages(other.objects_);
+            }
+          }
+        }
+        if (other.hasConsistencyLevel()) {
+          setConsistencyLevel(other.getConsistencyLevel());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 10: {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject m =
+                    input.readMessage(
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.parser(),
+                        extensionRegistry);
+                if (objectsBuilder_ == null) {
+                  ensureObjectsIsMutable();
+                  objects_.add(m);
+                } else {
+                  objectsBuilder_.addMessage(m);
+                }
+                break;
+              } // case 10
+              case 16: {
+                consistencyLevel_ = input.readEnum();
+                bitField0_ |= 0x00000002;
+                break;
+              } // case 16
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int bitField0_;
+
+      private java.util.List objects_ =
+        java.util.Collections.emptyList();
+      private void ensureObjectsIsMutable() {
+        if (!((bitField0_ & 0x00000001) != 0)) {
+          objects_ = new java.util.ArrayList(objects_);
+          bitField0_ |= 0x00000001;
+         }
+      }
+
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder> objectsBuilder_;
+
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public java.util.List getObjectsList() {
+        if (objectsBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(objects_);
+        } else {
+          return objectsBuilder_.getMessageList();
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public int getObjectsCount() {
+        if (objectsBuilder_ == null) {
+          return objects_.size();
+        } else {
+          return objectsBuilder_.getCount();
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getObjects(int index) {
+        if (objectsBuilder_ == null) {
+          return objects_.get(index);
+        } else {
+          return objectsBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder setObjects(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+        if (objectsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureObjectsIsMutable();
+          objects_.set(index, value);
+          onChanged();
+        } else {
+          objectsBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder setObjects(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+        if (objectsBuilder_ == null) {
+          ensureObjectsIsMutable();
+          objects_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          objectsBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder addObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+        if (objectsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureObjectsIsMutable();
+          objects_.add(value);
+          onChanged();
+        } else {
+          objectsBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder addObjects(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+        if (objectsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureObjectsIsMutable();
+          objects_.add(index, value);
+          onChanged();
+        } else {
+          objectsBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder addObjects(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+        if (objectsBuilder_ == null) {
+          ensureObjectsIsMutable();
+          objects_.add(builderForValue.build());
+          onChanged();
+        } else {
+          objectsBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder addObjects(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+        if (objectsBuilder_ == null) {
+          ensureObjectsIsMutable();
+          objects_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          objectsBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder addAllObjects(
+          java.lang.Iterable values) {
+        if (objectsBuilder_ == null) {
+          ensureObjectsIsMutable();
+          com.google.protobuf.AbstractMessageLite.Builder.addAll(
+              values, objects_);
+          onChanged();
+        } else {
+          objectsBuilder_.addAllMessages(values);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder clearObjects() {
+        if (objectsBuilder_ == null) {
+          objects_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000001);
+          onChanged();
+        } else {
+          objectsBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public Builder removeObjects(int index) {
+        if (objectsBuilder_ == null) {
+          ensureObjectsIsMutable();
+          objects_.remove(index);
+          onChanged();
+        } else {
+          objectsBuilder_.remove(index);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder getObjectsBuilder(
+          int index) {
+        return getObjectsFieldBuilder().getBuilder(index);
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getObjectsOrBuilder(
+          int index) {
+        if (objectsBuilder_ == null) {
+          return objects_.get(index);  } else {
+          return objectsBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public java.util.List 
+           getObjectsOrBuilderList() {
+        if (objectsBuilder_ != null) {
+          return objectsBuilder_.getMessageOrBuilderList();
+        } else {
+          return java.util.Collections.unmodifiableList(objects_);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder addObjectsBuilder() {
+        return getObjectsFieldBuilder().addBuilder(
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance());
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder addObjectsBuilder(
+          int index) {
+        return getObjectsFieldBuilder().addBuilder(
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance());
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject objects = 1;
+       */
+      public java.util.List 
+           getObjectsBuilderList() {
+        return getObjectsFieldBuilder().getBuilderList();
+      }
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder> 
+          getObjectsFieldBuilder() {
+        if (objectsBuilder_ == null) {
+          objectsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder>(
+                  objects_,
+                  ((bitField0_ & 0x00000001) != 0),
+                  getParentForChildren(),
+                  isClean());
+          objects_ = null;
+        }
+        return objectsBuilder_;
+      }
+
+      private int consistencyLevel_ = 0;
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return Whether the consistencyLevel field is set.
+       */
+      @java.lang.Override public boolean hasConsistencyLevel() {
+        return ((bitField0_ & 0x00000002) != 0);
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return The enum numeric value on the wire for consistencyLevel.
+       */
+      @java.lang.Override public int getConsistencyLevelValue() {
+        return consistencyLevel_;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @param value The enum numeric value on the wire for consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevelValue(int value) {
+        consistencyLevel_ = value;
+        bitField0_ |= 0x00000002;
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return The consistencyLevel.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @param value The consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevel(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        bitField0_ |= 0x00000002;
+        consistencyLevel_ = value.getNumber();
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return This builder for chaining.
+       */
+      public Builder clearConsistencyLevel() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        consistencyLevel_ = 0;
+        onChanged();
+        return this;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsRequest)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsRequest)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchObjectsRequest parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsRequest getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchReferencesRequestOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesRequest)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    java.util.List 
+        getReferencesList();
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getReferences(int index);
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    int getReferencesCount();
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    java.util.List 
+        getReferencesOrBuilderList();
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder(
+        int index);
+
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return Whether the consistencyLevel field is set.
+     */
+    boolean hasConsistencyLevel();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    int getConsistencyLevelValue();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The consistencyLevel.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchReferencesRequest}
+   */
+  public static final class BatchReferencesRequest extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesRequest)
+      BatchReferencesRequestOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchReferencesRequest.newBuilder() to construct.
+    private BatchReferencesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchReferencesRequest() {
+      references_ = java.util.Collections.emptyList();
+      consistencyLevel_ = 0;
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchReferencesRequest();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.Builder.class);
+    }
+
+    private int bitField0_;
+    public static final int REFERENCES_FIELD_NUMBER = 1;
+    @SuppressWarnings("serial")
+    private java.util.List references_;
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    @java.lang.Override
+    public java.util.List getReferencesList() {
+      return references_;
+    }
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    @java.lang.Override
+    public java.util.List 
+        getReferencesOrBuilderList() {
+      return references_;
+    }
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    @java.lang.Override
+    public int getReferencesCount() {
+      return references_.size();
+    }
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getReferences(int index) {
+      return references_.get(index);
+    }
+    /**
+     * repeated .weaviate.v1.BatchReference references = 1;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder(
+        int index) {
+      return references_.get(index);
+    }
+
+    public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 2;
+    private int consistencyLevel_ = 0;
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return Whether the consistencyLevel field is set.
+     */
+    @java.lang.Override public boolean hasConsistencyLevel() {
+      return ((bitField0_ & 0x00000001) != 0);
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    @java.lang.Override public int getConsistencyLevelValue() {
+      return consistencyLevel_;
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+     * @return The consistencyLevel.
+     */
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      for (int i = 0; i < references_.size(); i++) {
+        output.writeMessage(1, references_.get(i));
+      }
+      if (((bitField0_ & 0x00000001) != 0)) {
+        output.writeEnum(2, consistencyLevel_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      for (int i = 0; i < references_.size(); i++) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, references_.get(i));
+      }
+      if (((bitField0_ & 0x00000001) != 0)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeEnumSize(2, consistencyLevel_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest) obj;
+
+      if (!getReferencesList()
+          .equals(other.getReferencesList())) return false;
+      if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false;
+      if (hasConsistencyLevel()) {
+        if (consistencyLevel_ != other.consistencyLevel_) return false;
+      }
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      if (getReferencesCount() > 0) {
+        hash = (37 * hash) + REFERENCES_FIELD_NUMBER;
+        hash = (53 * hash) + getReferencesList().hashCode();
+      }
+      if (hasConsistencyLevel()) {
+        hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER;
+        hash = (53 * hash) + consistencyLevel_;
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchReferencesRequest}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesRequest)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequestOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        if (referencesBuilder_ == null) {
+          references_ = java.util.Collections.emptyList();
+        } else {
+          references_ = null;
+          referencesBuilder_.clear();
+        }
+        bitField0_ = (bitField0_ & ~0x00000001);
+        consistencyLevel_ = 0;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesRequest_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest(this);
+        buildPartialRepeatedFields(result);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest result) {
+        if (referencesBuilder_ == null) {
+          if (((bitField0_ & 0x00000001) != 0)) {
+            references_ = java.util.Collections.unmodifiableList(references_);
+            bitField0_ = (bitField0_ & ~0x00000001);
+          }
+          result.references_ = references_;
+        } else {
+          result.references_ = referencesBuilder_.build();
+        }
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest result) {
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000002) != 0)) {
+          result.consistencyLevel_ = consistencyLevel_;
+          to_bitField0_ |= 0x00000001;
+        }
+        result.bitField0_ |= to_bitField0_;
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest.getDefaultInstance()) return this;
+        if (referencesBuilder_ == null) {
+          if (!other.references_.isEmpty()) {
+            if (references_.isEmpty()) {
+              references_ = other.references_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+            } else {
+              ensureReferencesIsMutable();
+              references_.addAll(other.references_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.references_.isEmpty()) {
+            if (referencesBuilder_.isEmpty()) {
+              referencesBuilder_.dispose();
+              referencesBuilder_ = null;
+              references_ = other.references_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+              referencesBuilder_ = 
+                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                   getReferencesFieldBuilder() : null;
+            } else {
+              referencesBuilder_.addAllMessages(other.references_);
+            }
+          }
+        }
+        if (other.hasConsistencyLevel()) {
+          setConsistencyLevel(other.getConsistencyLevel());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 10: {
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference m =
+                    input.readMessage(
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.parser(),
+                        extensionRegistry);
+                if (referencesBuilder_ == null) {
+                  ensureReferencesIsMutable();
+                  references_.add(m);
+                } else {
+                  referencesBuilder_.addMessage(m);
+                }
+                break;
+              } // case 10
+              case 16: {
+                consistencyLevel_ = input.readEnum();
+                bitField0_ |= 0x00000002;
+                break;
+              } // case 16
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int bitField0_;
+
+      private java.util.List references_ =
+        java.util.Collections.emptyList();
+      private void ensureReferencesIsMutable() {
+        if (!((bitField0_ & 0x00000001) != 0)) {
+          references_ = new java.util.ArrayList(references_);
+          bitField0_ |= 0x00000001;
+         }
+      }
+
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder> referencesBuilder_;
+
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public java.util.List getReferencesList() {
+        if (referencesBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(references_);
+        } else {
+          return referencesBuilder_.getMessageList();
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public int getReferencesCount() {
+        if (referencesBuilder_ == null) {
+          return references_.size();
+        } else {
+          return referencesBuilder_.getCount();
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getReferences(int index) {
+        if (referencesBuilder_ == null) {
+          return references_.get(index);
+        } else {
+          return referencesBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder setReferences(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+        if (referencesBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureReferencesIsMutable();
+          references_.set(index, value);
+          onChanged();
+        } else {
+          referencesBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder setReferences(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+        if (referencesBuilder_ == null) {
+          ensureReferencesIsMutable();
+          references_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          referencesBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder addReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+        if (referencesBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureReferencesIsMutable();
+          references_.add(value);
+          onChanged();
+        } else {
+          referencesBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder addReferences(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+        if (referencesBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureReferencesIsMutable();
+          references_.add(index, value);
+          onChanged();
+        } else {
+          referencesBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder addReferences(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+        if (referencesBuilder_ == null) {
+          ensureReferencesIsMutable();
+          references_.add(builderForValue.build());
+          onChanged();
+        } else {
+          referencesBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder addReferences(
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+        if (referencesBuilder_ == null) {
+          ensureReferencesIsMutable();
+          references_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          referencesBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder addAllReferences(
+          java.lang.Iterable values) {
+        if (referencesBuilder_ == null) {
+          ensureReferencesIsMutable();
+          com.google.protobuf.AbstractMessageLite.Builder.addAll(
+              values, references_);
+          onChanged();
+        } else {
+          referencesBuilder_.addAllMessages(values);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder clearReferences() {
+        if (referencesBuilder_ == null) {
+          references_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000001);
+          onChanged();
+        } else {
+          referencesBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public Builder removeReferences(int index) {
+        if (referencesBuilder_ == null) {
+          ensureReferencesIsMutable();
+          references_.remove(index);
+          onChanged();
+        } else {
+          referencesBuilder_.remove(index);
+        }
+        return this;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder getReferencesBuilder(
+          int index) {
+        return getReferencesFieldBuilder().getBuilder(index);
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getReferencesOrBuilder(
+          int index) {
+        if (referencesBuilder_ == null) {
+          return references_.get(index);  } else {
+          return referencesBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public java.util.List 
+           getReferencesOrBuilderList() {
+        if (referencesBuilder_ != null) {
+          return referencesBuilder_.getMessageOrBuilderList();
+        } else {
+          return java.util.Collections.unmodifiableList(references_);
+        }
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder addReferencesBuilder() {
+        return getReferencesFieldBuilder().addBuilder(
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance());
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder addReferencesBuilder(
+          int index) {
+        return getReferencesFieldBuilder().addBuilder(
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance());
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference references = 1;
+       */
+      public java.util.List 
+           getReferencesBuilderList() {
+        return getReferencesFieldBuilder().getBuilderList();
+      }
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder> 
+          getReferencesFieldBuilder() {
+        if (referencesBuilder_ == null) {
+          referencesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder>(
+                  references_,
+                  ((bitField0_ & 0x00000001) != 0),
+                  getParentForChildren(),
+                  isClean());
+          references_ = null;
+        }
+        return referencesBuilder_;
+      }
+
+      private int consistencyLevel_ = 0;
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return Whether the consistencyLevel field is set.
+       */
+      @java.lang.Override public boolean hasConsistencyLevel() {
+        return ((bitField0_ & 0x00000002) != 0);
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return The enum numeric value on the wire for consistencyLevel.
+       */
+      @java.lang.Override public int getConsistencyLevelValue() {
+        return consistencyLevel_;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @param value The enum numeric value on the wire for consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevelValue(int value) {
+        consistencyLevel_ = value;
+        bitField0_ |= 0x00000002;
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return The consistencyLevel.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @param value The consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevel(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        bitField0_ |= 0x00000002;
+        consistencyLevel_ = value.getNumber();
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 2;
+       * @return This builder for chaining.
+       */
+      public Builder clearConsistencyLevel() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        consistencyLevel_ = 0;
+        onChanged();
+        return this;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesRequest)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesRequest)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchReferencesRequest parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesRequest getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchSendRequestOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * string stream_id = 1;
+     * @return The streamId.
+     */
+    java.lang.String getStreamId();
+    /**
+     * string stream_id = 1;
+     * @return The bytes for streamId.
+     */
+    com.google.protobuf.ByteString
+        getStreamIdBytes();
+
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     * @return Whether the objects field is set.
+     */
+    boolean hasObjects();
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     * @return The objects.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getObjects();
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     * @return Whether the references field is set.
+     */
+    boolean hasReferences();
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     * @return The references.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getReferences();
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     * @return Whether the stop field is set.
+     */
+    boolean hasStop();
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     * @return The stop.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getStop();
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder();
+
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.MessageCase getMessageCase();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchSendRequest}
+   */
+  public static final class BatchSendRequest extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest)
+      BatchSendRequestOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchSendRequest.newBuilder() to construct.
+    private BatchSendRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchSendRequest() {
+      streamId_ = "";
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchSendRequest();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Builder.class);
+    }
+
+    public interface StopOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.Stop)
+        com.google.protobuf.MessageOrBuilder {
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchSendRequest.Stop}
+     */
+    public static final class Stop extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.Stop)
+        StopOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Stop.newBuilder() to construct.
+      private Stop(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Stop() {
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Stop();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder.class);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) obj;
+
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchSendRequest.Stop}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.Stop)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop(this);
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance()) return this;
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.Stop)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.Stop)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Stop parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface ObjectsOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.Objects)
+        com.google.protobuf.MessageOrBuilder {
+
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      java.util.List 
+          getValuesList();
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getValues(int index);
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      int getValuesCount();
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      java.util.List 
+          getValuesOrBuilderList();
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder(
+          int index);
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchSendRequest.Objects}
+     */
+    public static final class Objects extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.Objects)
+        ObjectsOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Objects.newBuilder() to construct.
+      private Objects(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Objects() {
+        values_ = java.util.Collections.emptyList();
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Objects();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder.class);
+      }
+
+      public static final int VALUES_FIELD_NUMBER = 1;
+      @SuppressWarnings("serial")
+      private java.util.List values_;
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      @java.lang.Override
+      public java.util.List getValuesList() {
+        return values_;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      @java.lang.Override
+      public java.util.List 
+          getValuesOrBuilderList() {
+        return values_;
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      @java.lang.Override
+      public int getValuesCount() {
+        return values_.size();
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getValues(int index) {
+        return values_.get(index);
+      }
+      /**
+       * repeated .weaviate.v1.BatchObject values = 1;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder(
+          int index) {
+        return values_.get(index);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        for (int i = 0; i < values_.size(); i++) {
+          output.writeMessage(1, values_.get(i));
+        }
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        for (int i = 0; i < values_.size(); i++) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeMessageSize(1, values_.get(i));
+        }
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) obj;
+
+        if (!getValuesList()
+            .equals(other.getValuesList())) return false;
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        if (getValuesCount() > 0) {
+          hash = (37 * hash) + VALUES_FIELD_NUMBER;
+          hash = (53 * hash) + getValuesList().hashCode();
+        }
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchSendRequest.Objects}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.Objects)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          bitField0_ = 0;
+          if (valuesBuilder_ == null) {
+            values_ = java.util.Collections.emptyList();
+          } else {
+            values_ = null;
+            valuesBuilder_.clear();
+          }
+          bitField0_ = (bitField0_ & ~0x00000001);
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects(this);
+          buildPartialRepeatedFields(result);
+          if (bitField0_ != 0) { buildPartial0(result); }
+          onBuilt();
+          return result;
+        }
+
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects result) {
+          if (valuesBuilder_ == null) {
+            if (((bitField0_ & 0x00000001) != 0)) {
+              values_ = java.util.Collections.unmodifiableList(values_);
+              bitField0_ = (bitField0_ & ~0x00000001);
+            }
+            result.values_ = values_;
+          } else {
+            result.values_ = valuesBuilder_.build();
+          }
+        }
+
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects result) {
+          int from_bitField0_ = bitField0_;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance()) return this;
+          if (valuesBuilder_ == null) {
+            if (!other.values_.isEmpty()) {
+              if (values_.isEmpty()) {
+                values_ = other.values_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+              } else {
+                ensureValuesIsMutable();
+                values_.addAll(other.values_);
+              }
+              onChanged();
+            }
+          } else {
+            if (!other.values_.isEmpty()) {
+              if (valuesBuilder_.isEmpty()) {
+                valuesBuilder_.dispose();
+                valuesBuilder_ = null;
+                values_ = other.values_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+                valuesBuilder_ = 
+                  com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                     getValuesFieldBuilder() : null;
+              } else {
+                valuesBuilder_.addAllMessages(other.values_);
+              }
+            }
+          }
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                case 10: {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject m =
+                      input.readMessage(
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.parser(),
+                          extensionRegistry);
+                  if (valuesBuilder_ == null) {
+                    ensureValuesIsMutable();
+                    values_.add(m);
+                  } else {
+                    valuesBuilder_.addMessage(m);
+                  }
+                  break;
+                } // case 10
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        private int bitField0_;
+
+        private java.util.List values_ =
+          java.util.Collections.emptyList();
+        private void ensureValuesIsMutable() {
+          if (!((bitField0_ & 0x00000001) != 0)) {
+            values_ = new java.util.ArrayList(values_);
+            bitField0_ |= 0x00000001;
+           }
+        }
+
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder> valuesBuilder_;
+
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public java.util.List getValuesList() {
+          if (valuesBuilder_ == null) {
+            return java.util.Collections.unmodifiableList(values_);
+          } else {
+            return valuesBuilder_.getMessageList();
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public int getValuesCount() {
+          if (valuesBuilder_ == null) {
+            return values_.size();
+          } else {
+            return valuesBuilder_.getCount();
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getValues(int index) {
+          if (valuesBuilder_ == null) {
+            return values_.get(index);
+          } else {
+            return valuesBuilder_.getMessage(index);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder setValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.set(index, value);
+            onChanged();
+          } else {
+            valuesBuilder_.setMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder setValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.set(index, builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.setMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder addValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.add(value);
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder addValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.add(index, value);
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder addValues(
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.add(builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder addValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.add(index, builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder addAllValues(
+            java.lang.Iterable values) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                values, values_);
+            onChanged();
+          } else {
+            valuesBuilder_.addAllMessages(values);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder clearValues() {
+          if (valuesBuilder_ == null) {
+            values_ = java.util.Collections.emptyList();
+            bitField0_ = (bitField0_ & ~0x00000001);
+            onChanged();
+          } else {
+            valuesBuilder_.clear();
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public Builder removeValues(int index) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.remove(index);
+            onChanged();
+          } else {
+            valuesBuilder_.remove(index);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder getValuesBuilder(
+            int index) {
+          return getValuesFieldBuilder().getBuilder(index);
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder getValuesOrBuilder(
+            int index) {
+          if (valuesBuilder_ == null) {
+            return values_.get(index);  } else {
+            return valuesBuilder_.getMessageOrBuilder(index);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public java.util.List 
+             getValuesOrBuilderList() {
+          if (valuesBuilder_ != null) {
+            return valuesBuilder_.getMessageOrBuilderList();
+          } else {
+            return java.util.Collections.unmodifiableList(values_);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder addValuesBuilder() {
+          return getValuesFieldBuilder().addBuilder(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance());
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder addValuesBuilder(
+            int index) {
+          return getValuesFieldBuilder().addBuilder(
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance());
+        }
+        /**
+         * repeated .weaviate.v1.BatchObject values = 1;
+         */
+        public java.util.List 
+             getValuesBuilderList() {
+          return getValuesFieldBuilder().getBuilderList();
+        }
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder> 
+            getValuesFieldBuilder() {
+          if (valuesBuilder_ == null) {
+            valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder>(
+                    values_,
+                    ((bitField0_ & 0x00000001) != 0),
+                    getParentForChildren(),
+                    isClean());
+            values_ = null;
+          }
+          return valuesBuilder_;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.Objects)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.Objects)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Objects parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface ReferencesOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendRequest.References)
+        com.google.protobuf.MessageOrBuilder {
+
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      java.util.List 
+          getValuesList();
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getValues(int index);
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      int getValuesCount();
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      java.util.List 
+          getValuesOrBuilderList();
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder(
+          int index);
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchSendRequest.References}
+     */
+    public static final class References extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendRequest.References)
+        ReferencesOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use References.newBuilder() to construct.
+      private References(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private References() {
+        values_ = java.util.Collections.emptyList();
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new References();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder.class);
+      }
+
+      public static final int VALUES_FIELD_NUMBER = 1;
+      @SuppressWarnings("serial")
+      private java.util.List values_;
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      @java.lang.Override
+      public java.util.List getValuesList() {
+        return values_;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      @java.lang.Override
+      public java.util.List 
+          getValuesOrBuilderList() {
+        return values_;
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      @java.lang.Override
+      public int getValuesCount() {
+        return values_.size();
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getValues(int index) {
+        return values_.get(index);
+      }
+      /**
+       * repeated .weaviate.v1.BatchReference values = 1;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder(
+          int index) {
+        return values_.get(index);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        for (int i = 0; i < values_.size(); i++) {
+          output.writeMessage(1, values_.get(i));
+        }
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        for (int i = 0; i < values_.size(); i++) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeMessageSize(1, values_.get(i));
+        }
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) obj;
+
+        if (!getValuesList()
+            .equals(other.getValuesList())) return false;
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        if (getValuesCount() > 0) {
+          hash = (37 * hash) + VALUES_FIELD_NUMBER;
+          hash = (53 * hash) + getValuesList().hashCode();
+        }
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchSendRequest.References}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest.References)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          bitField0_ = 0;
+          if (valuesBuilder_ == null) {
+            values_ = java.util.Collections.emptyList();
+          } else {
+            values_ = null;
+            valuesBuilder_.clear();
+          }
+          bitField0_ = (bitField0_ & ~0x00000001);
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_References_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References(this);
+          buildPartialRepeatedFields(result);
+          if (bitField0_ != 0) { buildPartial0(result); }
+          onBuilt();
+          return result;
+        }
+
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References result) {
+          if (valuesBuilder_ == null) {
+            if (((bitField0_ & 0x00000001) != 0)) {
+              values_ = java.util.Collections.unmodifiableList(values_);
+              bitField0_ = (bitField0_ & ~0x00000001);
+            }
+            result.values_ = values_;
+          } else {
+            result.values_ = valuesBuilder_.build();
+          }
+        }
+
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References result) {
+          int from_bitField0_ = bitField0_;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance()) return this;
+          if (valuesBuilder_ == null) {
+            if (!other.values_.isEmpty()) {
+              if (values_.isEmpty()) {
+                values_ = other.values_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+              } else {
+                ensureValuesIsMutable();
+                values_.addAll(other.values_);
+              }
+              onChanged();
+            }
+          } else {
+            if (!other.values_.isEmpty()) {
+              if (valuesBuilder_.isEmpty()) {
+                valuesBuilder_.dispose();
+                valuesBuilder_ = null;
+                values_ = other.values_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+                valuesBuilder_ = 
+                  com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                     getValuesFieldBuilder() : null;
+              } else {
+                valuesBuilder_.addAllMessages(other.values_);
+              }
+            }
+          }
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                case 10: {
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference m =
+                      input.readMessage(
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.parser(),
+                          extensionRegistry);
+                  if (valuesBuilder_ == null) {
+                    ensureValuesIsMutable();
+                    values_.add(m);
+                  } else {
+                    valuesBuilder_.addMessage(m);
+                  }
+                  break;
+                } // case 10
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        private int bitField0_;
+
+        private java.util.List values_ =
+          java.util.Collections.emptyList();
+        private void ensureValuesIsMutable() {
+          if (!((bitField0_ & 0x00000001) != 0)) {
+            values_ = new java.util.ArrayList(values_);
+            bitField0_ |= 0x00000001;
+           }
+        }
+
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder> valuesBuilder_;
+
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public java.util.List getValuesList() {
+          if (valuesBuilder_ == null) {
+            return java.util.Collections.unmodifiableList(values_);
+          } else {
+            return valuesBuilder_.getMessageList();
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public int getValuesCount() {
+          if (valuesBuilder_ == null) {
+            return values_.size();
+          } else {
+            return valuesBuilder_.getCount();
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getValues(int index) {
+          if (valuesBuilder_ == null) {
+            return values_.get(index);
+          } else {
+            return valuesBuilder_.getMessage(index);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder setValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.set(index, value);
+            onChanged();
+          } else {
+            valuesBuilder_.setMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder setValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.set(index, builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.setMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder addValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.add(value);
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder addValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference value) {
+          if (valuesBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureValuesIsMutable();
+            values_.add(index, value);
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder addValues(
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.add(builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder addValues(
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder builderForValue) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.add(index, builderForValue.build());
+            onChanged();
+          } else {
+            valuesBuilder_.addMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder addAllValues(
+            java.lang.Iterable values) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                values, values_);
+            onChanged();
+          } else {
+            valuesBuilder_.addAllMessages(values);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder clearValues() {
+          if (valuesBuilder_ == null) {
+            values_ = java.util.Collections.emptyList();
+            bitField0_ = (bitField0_ & ~0x00000001);
+            onChanged();
+          } else {
+            valuesBuilder_.clear();
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public Builder removeValues(int index) {
+          if (valuesBuilder_ == null) {
+            ensureValuesIsMutable();
+            values_.remove(index);
+            onChanged();
+          } else {
+            valuesBuilder_.remove(index);
+          }
+          return this;
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder getValuesBuilder(
+            int index) {
+          return getValuesFieldBuilder().getBuilder(index);
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder getValuesOrBuilder(
+            int index) {
+          if (valuesBuilder_ == null) {
+            return values_.get(index);  } else {
+            return valuesBuilder_.getMessageOrBuilder(index);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public java.util.List 
+             getValuesOrBuilderList() {
+          if (valuesBuilder_ != null) {
+            return valuesBuilder_.getMessageOrBuilderList();
+          } else {
+            return java.util.Collections.unmodifiableList(values_);
+          }
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder addValuesBuilder() {
+          return getValuesFieldBuilder().addBuilder(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance());
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder addValuesBuilder(
+            int index) {
+          return getValuesFieldBuilder().addBuilder(
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance());
+        }
+        /**
+         * repeated .weaviate.v1.BatchReference values = 1;
+         */
+        public java.util.List 
+             getValuesBuilderList() {
+          return getValuesFieldBuilder().getBuilderList();
+        }
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder> 
+            getValuesFieldBuilder() {
+          if (valuesBuilder_ == null) {
+            valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder>(
+                    values_,
+                    ((bitField0_ & 0x00000001) != 0),
+                    getParentForChildren(),
+                    isClean());
+            values_ = null;
+          }
+          return valuesBuilder_;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest.References)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest.References)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public References parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    private int messageCase_ = 0;
+    @SuppressWarnings("serial")
+    private java.lang.Object message_;
+    public enum MessageCase
+        implements com.google.protobuf.Internal.EnumLite,
+            com.google.protobuf.AbstractMessage.InternalOneOfEnum {
+      OBJECTS(2),
+      REFERENCES(3),
+      STOP(4),
+      MESSAGE_NOT_SET(0);
+      private final int value;
+      private MessageCase(int value) {
+        this.value = value;
+      }
+      /**
+       * @param value The number of the enum to look for.
+       * @return The enum associated with the given number.
+       * @deprecated Use {@link #forNumber(int)} instead.
+       */
+      @java.lang.Deprecated
+      public static MessageCase valueOf(int value) {
+        return forNumber(value);
+      }
+
+      public static MessageCase forNumber(int value) {
+        switch (value) {
+          case 2: return OBJECTS;
+          case 3: return REFERENCES;
+          case 4: return STOP;
+          case 0: return MESSAGE_NOT_SET;
+          default: return null;
+        }
+      }
+      public int getNumber() {
+        return this.value;
+      }
+    };
+
+    public MessageCase
+    getMessageCase() {
+      return MessageCase.forNumber(
+          messageCase_);
+    }
+
+    public static final int STREAM_ID_FIELD_NUMBER = 1;
+    @SuppressWarnings("serial")
+    private volatile java.lang.Object streamId_ = "";
+    /**
+     * string stream_id = 1;
+     * @return The streamId.
+     */
+    @java.lang.Override
+    public java.lang.String getStreamId() {
+      java.lang.Object ref = streamId_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        streamId_ = s;
+        return s;
+      }
+    }
+    /**
+     * string stream_id = 1;
+     * @return The bytes for streamId.
+     */
+    @java.lang.Override
+    public com.google.protobuf.ByteString
+        getStreamIdBytes() {
+      java.lang.Object ref = streamId_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        streamId_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int OBJECTS_FIELD_NUMBER = 2;
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     * @return Whether the objects field is set.
+     */
+    @java.lang.Override
+    public boolean hasObjects() {
+      return messageCase_ == 2;
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     * @return The objects.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getObjects() {
+      if (messageCase_ == 2) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder() {
+      if (messageCase_ == 2) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+    }
+
+    public static final int REFERENCES_FIELD_NUMBER = 3;
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     * @return Whether the references field is set.
+     */
+    @java.lang.Override
+    public boolean hasReferences() {
+      return messageCase_ == 3;
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     * @return The references.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getReferences() {
+      if (messageCase_ == 3) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.References references = 3;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder() {
+      if (messageCase_ == 3) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+    }
+
+    public static final int STOP_FIELD_NUMBER = 4;
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     * @return Whether the stop field is set.
+     */
+    @java.lang.Override
+    public boolean hasStop() {
+      return messageCase_ == 4;
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     * @return The stop.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getStop() {
+      if (messageCase_ == 4) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder() {
+      if (messageCase_ == 4) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) {
+        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, streamId_);
+      }
+      if (messageCase_ == 2) {
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_);
+      }
+      if (messageCase_ == 3) {
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_);
+      }
+      if (messageCase_ == 4) {
+        output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) {
+        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, streamId_);
+      }
+      if (messageCase_ == 2) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_);
+      }
+      if (messageCase_ == 3) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_);
+      }
+      if (messageCase_ == 4) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest) obj;
+
+      if (!getStreamId()
+          .equals(other.getStreamId())) return false;
+      if (!getMessageCase().equals(other.getMessageCase())) return false;
+      switch (messageCase_) {
+        case 2:
+          if (!getObjects()
+              .equals(other.getObjects())) return false;
+          break;
+        case 3:
+          if (!getReferences()
+              .equals(other.getReferences())) return false;
+          break;
+        case 4:
+          if (!getStop()
+              .equals(other.getStop())) return false;
+          break;
+        case 0:
+        default:
+      }
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      hash = (37 * hash) + STREAM_ID_FIELD_NUMBER;
+      hash = (53 * hash) + getStreamId().hashCode();
+      switch (messageCase_) {
+        case 2:
+          hash = (37 * hash) + OBJECTS_FIELD_NUMBER;
+          hash = (53 * hash) + getObjects().hashCode();
+          break;
+        case 3:
+          hash = (37 * hash) + REFERENCES_FIELD_NUMBER;
+          hash = (53 * hash) + getReferences().hashCode();
+          break;
+        case 4:
+          hash = (37 * hash) + STOP_FIELD_NUMBER;
+          hash = (53 * hash) + getStop().hashCode();
+          break;
+        case 0:
+        default:
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchSendRequest}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendRequest)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequestOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        streamId_ = "";
+        if (objectsBuilder_ != null) {
+          objectsBuilder_.clear();
+        }
+        if (referencesBuilder_ != null) {
+          referencesBuilder_.clear();
+        }
+        if (stopBuilder_ != null) {
+          stopBuilder_.clear();
+        }
+        messageCase_ = 0;
+        message_ = null;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendRequest_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest(this);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        buildPartialOneofs(result);
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest result) {
+        int from_bitField0_ = bitField0_;
+        if (((from_bitField0_ & 0x00000001) != 0)) {
+          result.streamId_ = streamId_;
+        }
+      }
+
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest result) {
+        result.messageCase_ = messageCase_;
+        result.message_ = this.message_;
+        if (messageCase_ == 2 &&
+            objectsBuilder_ != null) {
+          result.message_ = objectsBuilder_.build();
+        }
+        if (messageCase_ == 3 &&
+            referencesBuilder_ != null) {
+          result.message_ = referencesBuilder_.build();
+        }
+        if (messageCase_ == 4 &&
+            stopBuilder_ != null) {
+          result.message_ = stopBuilder_.build();
+        }
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.getDefaultInstance()) return this;
+        if (!other.getStreamId().isEmpty()) {
+          streamId_ = other.streamId_;
+          bitField0_ |= 0x00000001;
+          onChanged();
+        }
+        switch (other.getMessageCase()) {
+          case OBJECTS: {
+            mergeObjects(other.getObjects());
+            break;
+          }
+          case REFERENCES: {
+            mergeReferences(other.getReferences());
+            break;
+          }
+          case STOP: {
+            mergeStop(other.getStop());
+            break;
+          }
+          case MESSAGE_NOT_SET: {
+            break;
+          }
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 10: {
+                streamId_ = input.readStringRequireUtf8();
+                bitField0_ |= 0x00000001;
+                break;
+              } // case 10
+              case 18: {
+                input.readMessage(
+                    getObjectsFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 2;
+                break;
+              } // case 18
+              case 26: {
+                input.readMessage(
+                    getReferencesFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 3;
+                break;
+              } // case 26
+              case 34: {
+                input.readMessage(
+                    getStopFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 4;
+                break;
+              } // case 34
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int messageCase_ = 0;
+      private java.lang.Object message_;
+      public MessageCase
+          getMessageCase() {
+        return MessageCase.forNumber(
+            messageCase_);
+      }
+
+      public Builder clearMessage() {
+        messageCase_ = 0;
+        message_ = null;
+        onChanged();
+        return this;
+      }
+
+      private int bitField0_;
+
+      private java.lang.Object streamId_ = "";
+      /**
+       * string stream_id = 1;
+       * @return The streamId.
+       */
+      public java.lang.String getStreamId() {
+        java.lang.Object ref = streamId_;
+        if (!(ref instanceof java.lang.String)) {
+          com.google.protobuf.ByteString bs =
+              (com.google.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          streamId_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * string stream_id = 1;
+       * @return The bytes for streamId.
+       */
+      public com.google.protobuf.ByteString
+          getStreamIdBytes() {
+        java.lang.Object ref = streamId_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          streamId_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * string stream_id = 1;
+       * @param value The streamId to set.
+       * @return This builder for chaining.
+       */
+      public Builder setStreamId(
+          java.lang.String value) {
+        if (value == null) { throw new NullPointerException(); }
+        streamId_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+      /**
+       * string stream_id = 1;
+       * @return This builder for chaining.
+       */
+      public Builder clearStreamId() {
+        streamId_ = getDefaultInstance().getStreamId();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        onChanged();
+        return this;
+      }
+      /**
+       * string stream_id = 1;
+       * @param value The bytes for streamId to set.
+       * @return This builder for chaining.
+       */
+      public Builder setStreamIdBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) { throw new NullPointerException(); }
+        checkByteStringIsUtf8(value);
+        streamId_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder> objectsBuilder_;
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       * @return Whether the objects field is set.
+       */
+      @java.lang.Override
+      public boolean hasObjects() {
+        return messageCase_ == 2;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       * @return The objects.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects getObjects() {
+        if (objectsBuilder_ == null) {
+          if (messageCase_ == 2) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+        } else {
+          if (messageCase_ == 2) {
+            return objectsBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      public Builder setObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects value) {
+        if (objectsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          objectsBuilder_.setMessage(value);
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      public Builder setObjects(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder builderForValue) {
+        if (objectsBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          objectsBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      public Builder mergeObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects value) {
+        if (objectsBuilder_ == null) {
+          if (messageCase_ == 2 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 2) {
+            objectsBuilder_.mergeFrom(value);
+          } else {
+            objectsBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      public Builder clearObjects() {
+        if (objectsBuilder_ == null) {
+          if (messageCase_ == 2) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 2) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          objectsBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder getObjectsBuilder() {
+        return getObjectsFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder getObjectsOrBuilder() {
+        if ((messageCase_ == 2) && (objectsBuilder_ != null)) {
+          return objectsBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 2) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Objects objects = 2;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder> 
+          getObjectsFieldBuilder() {
+        if (objectsBuilder_ == null) {
+          if (!(messageCase_ == 2)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.getDefaultInstance();
+          }
+          objectsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ObjectsOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Objects) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 2;
+        onChanged();
+        return objectsBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder> referencesBuilder_;
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       * @return Whether the references field is set.
+       */
+      @java.lang.Override
+      public boolean hasReferences() {
+        return messageCase_ == 3;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       * @return The references.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References getReferences() {
+        if (referencesBuilder_ == null) {
+          if (messageCase_ == 3) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+        } else {
+          if (messageCase_ == 3) {
+            return referencesBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      public Builder setReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References value) {
+        if (referencesBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          referencesBuilder_.setMessage(value);
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      public Builder setReferences(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder builderForValue) {
+        if (referencesBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          referencesBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      public Builder mergeReferences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References value) {
+        if (referencesBuilder_ == null) {
+          if (messageCase_ == 3 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 3) {
+            referencesBuilder_.mergeFrom(value);
+          } else {
+            referencesBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      public Builder clearReferences() {
+        if (referencesBuilder_ == null) {
+          if (messageCase_ == 3) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 3) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          referencesBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder getReferencesBuilder() {
+        return getReferencesFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder getReferencesOrBuilder() {
+        if ((messageCase_ == 3) && (referencesBuilder_ != null)) {
+          return referencesBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 3) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.References references = 3;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder> 
+          getReferencesFieldBuilder() {
+        if (referencesBuilder_ == null) {
+          if (!(messageCase_ == 3)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.getDefaultInstance();
+          }
+          referencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.ReferencesOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.References) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 3;
+        onChanged();
+        return referencesBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder> stopBuilder_;
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       * @return Whether the stop field is set.
+       */
+      @java.lang.Override
+      public boolean hasStop() {
+        return messageCase_ == 4;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       * @return The stop.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop getStop() {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+        } else {
+          if (messageCase_ == 4) {
+            return stopBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      public Builder setStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop value) {
+        if (stopBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          stopBuilder_.setMessage(value);
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      public Builder setStop(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder builderForValue) {
+        if (stopBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          stopBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      public Builder mergeStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop value) {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 4) {
+            stopBuilder_.mergeFrom(value);
+          } else {
+            stopBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      public Builder clearStop() {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 4) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          stopBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder getStopBuilder() {
+        return getStopFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder getStopOrBuilder() {
+        if ((messageCase_ == 4) && (stopBuilder_ != null)) {
+          return stopBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 4) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchSendRequest.Stop stop = 4;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder> 
+          getStopFieldBuilder() {
+        if (stopBuilder_ == null) {
+          if (!(messageCase_ == 4)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.getDefaultInstance();
+          }
+          stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.StopOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest.Stop) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 4;
+        onChanged();
+        return stopBuilder_;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendRequest)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendRequest)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchSendRequest parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendRequest getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchSendReplyOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchSendReply)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * int32 next_batch_size = 1;
+     * @return The nextBatchSize.
+     */
+    int getNextBatchSize();
+
+    /**
+     * float backoff_seconds = 2;
+     * @return The backoffSeconds.
+     */
+    float getBackoffSeconds();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchSendReply}
+   */
+  public static final class BatchSendReply extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchSendReply)
+      BatchSendReplyOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchSendReply.newBuilder() to construct.
+    private BatchSendReply(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchSendReply() {
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchSendReply();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.Builder.class);
+    }
+
+    public static final int NEXT_BATCH_SIZE_FIELD_NUMBER = 1;
+    private int nextBatchSize_ = 0;
+    /**
+     * int32 next_batch_size = 1;
+     * @return The nextBatchSize.
+     */
+    @java.lang.Override
+    public int getNextBatchSize() {
+      return nextBatchSize_;
+    }
+
+    public static final int BACKOFF_SECONDS_FIELD_NUMBER = 2;
+    private float backoffSeconds_ = 0F;
+    /**
+     * float backoff_seconds = 2;
+     * @return The backoffSeconds.
+     */
+    @java.lang.Override
+    public float getBackoffSeconds() {
+      return backoffSeconds_;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (nextBatchSize_ != 0) {
+        output.writeInt32(1, nextBatchSize_);
+      }
+      if (java.lang.Float.floatToRawIntBits(backoffSeconds_) != 0) {
+        output.writeFloat(2, backoffSeconds_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (nextBatchSize_ != 0) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(1, nextBatchSize_);
+      }
+      if (java.lang.Float.floatToRawIntBits(backoffSeconds_) != 0) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeFloatSize(2, backoffSeconds_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply) obj;
+
+      if (getNextBatchSize()
+          != other.getNextBatchSize()) return false;
+      if (java.lang.Float.floatToIntBits(getBackoffSeconds())
+          != java.lang.Float.floatToIntBits(
+              other.getBackoffSeconds())) return false;
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      hash = (37 * hash) + NEXT_BATCH_SIZE_FIELD_NUMBER;
+      hash = (53 * hash) + getNextBatchSize();
+      hash = (37 * hash) + BACKOFF_SECONDS_FIELD_NUMBER;
+      hash = (53 * hash) + java.lang.Float.floatToIntBits(
+          getBackoffSeconds());
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchSendReply}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchSendReply)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReplyOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        nextBatchSize_ = 0;
+        backoffSeconds_ = 0F;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchSendReply_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply(this);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply result) {
+        int from_bitField0_ = bitField0_;
+        if (((from_bitField0_ & 0x00000001) != 0)) {
+          result.nextBatchSize_ = nextBatchSize_;
+        }
+        if (((from_bitField0_ & 0x00000002) != 0)) {
+          result.backoffSeconds_ = backoffSeconds_;
+        }
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply.getDefaultInstance()) return this;
+        if (other.getNextBatchSize() != 0) {
+          setNextBatchSize(other.getNextBatchSize());
+        }
+        if (other.getBackoffSeconds() != 0F) {
+          setBackoffSeconds(other.getBackoffSeconds());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 8: {
+                nextBatchSize_ = input.readInt32();
+                bitField0_ |= 0x00000001;
+                break;
+              } // case 8
+              case 21: {
+                backoffSeconds_ = input.readFloat();
+                bitField0_ |= 0x00000002;
+                break;
+              } // case 21
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int bitField0_;
+
+      private int nextBatchSize_ ;
+      /**
+       * int32 next_batch_size = 1;
+       * @return The nextBatchSize.
+       */
+      @java.lang.Override
+      public int getNextBatchSize() {
+        return nextBatchSize_;
+      }
+      /**
+       * int32 next_batch_size = 1;
+       * @param value The nextBatchSize to set.
+       * @return This builder for chaining.
+       */
+      public Builder setNextBatchSize(int value) {
+
+        nextBatchSize_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+      /**
+       * int32 next_batch_size = 1;
+       * @return This builder for chaining.
+       */
+      public Builder clearNextBatchSize() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        nextBatchSize_ = 0;
+        onChanged();
+        return this;
+      }
+
+      private float backoffSeconds_ ;
+      /**
+       * float backoff_seconds = 2;
+       * @return The backoffSeconds.
+       */
+      @java.lang.Override
+      public float getBackoffSeconds() {
+        return backoffSeconds_;
+      }
+      /**
+       * float backoff_seconds = 2;
+       * @param value The backoffSeconds to set.
+       * @return This builder for chaining.
+       */
+      public Builder setBackoffSeconds(float value) {
+
+        backoffSeconds_ = value;
+        bitField0_ |= 0x00000002;
+        onChanged();
+        return this;
+      }
+      /**
+       * float backoff_seconds = 2;
+       * @return This builder for chaining.
+       */
+      public Builder clearBackoffSeconds() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        backoffSeconds_ = 0F;
+        onChanged();
+        return this;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchSendReply)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchSendReply)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchSendReply parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchSendReply getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchStreamRequestOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamRequest)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return Whether the consistencyLevel field is set.
+     */
+    boolean hasConsistencyLevel();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    int getConsistencyLevelValue();
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return The consistencyLevel.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel();
+
+    /**
+     * optional int32 object_index = 2;
+     * @return Whether the objectIndex field is set.
+     */
+    boolean hasObjectIndex();
+    /**
+     * optional int32 object_index = 2;
+     * @return The objectIndex.
+     */
+    int getObjectIndex();
+
+    /**
+     * optional int32 reference_index = 3;
+     * @return Whether the referenceIndex field is set.
+     */
+    boolean hasReferenceIndex();
+    /**
+     * optional int32 reference_index = 3;
+     * @return The referenceIndex.
+     */
+    int getReferenceIndex();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchStreamRequest}
+   */
+  public static final class BatchStreamRequest extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamRequest)
+      BatchStreamRequestOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchStreamRequest.newBuilder() to construct.
+    private BatchStreamRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchStreamRequest() {
+      consistencyLevel_ = 0;
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchStreamRequest();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.Builder.class);
+    }
+
+    private int bitField0_;
+    public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 1;
+    private int consistencyLevel_ = 0;
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return Whether the consistencyLevel field is set.
+     */
+    @java.lang.Override public boolean hasConsistencyLevel() {
+      return ((bitField0_ & 0x00000001) != 0);
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return The enum numeric value on the wire for consistencyLevel.
+     */
+    @java.lang.Override public int getConsistencyLevelValue() {
+      return consistencyLevel_;
+    }
+    /**
+     * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+     * @return The consistencyLevel.
+     */
+    @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+      return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+    }
+
+    public static final int OBJECT_INDEX_FIELD_NUMBER = 2;
+    private int objectIndex_ = 0;
+    /**
+     * optional int32 object_index = 2;
+     * @return Whether the objectIndex field is set.
+     */
+    @java.lang.Override
+    public boolean hasObjectIndex() {
+      return ((bitField0_ & 0x00000002) != 0);
+    }
+    /**
+     * optional int32 object_index = 2;
+     * @return The objectIndex.
+     */
+    @java.lang.Override
+    public int getObjectIndex() {
+      return objectIndex_;
+    }
+
+    public static final int REFERENCE_INDEX_FIELD_NUMBER = 3;
+    private int referenceIndex_ = 0;
+    /**
+     * optional int32 reference_index = 3;
+     * @return Whether the referenceIndex field is set.
+     */
+    @java.lang.Override
+    public boolean hasReferenceIndex() {
+      return ((bitField0_ & 0x00000004) != 0);
+    }
+    /**
+     * optional int32 reference_index = 3;
+     * @return The referenceIndex.
+     */
+    @java.lang.Override
+    public int getReferenceIndex() {
+      return referenceIndex_;
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (((bitField0_ & 0x00000001) != 0)) {
+        output.writeEnum(1, consistencyLevel_);
+      }
+      if (((bitField0_ & 0x00000002) != 0)) {
+        output.writeInt32(2, objectIndex_);
+      }
+      if (((bitField0_ & 0x00000004) != 0)) {
+        output.writeInt32(3, referenceIndex_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) != 0)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeEnumSize(1, consistencyLevel_);
+      }
+      if (((bitField0_ & 0x00000002) != 0)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(2, objectIndex_);
+      }
+      if (((bitField0_ & 0x00000004) != 0)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt32Size(3, referenceIndex_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest) obj;
+
+      if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false;
+      if (hasConsistencyLevel()) {
+        if (consistencyLevel_ != other.consistencyLevel_) return false;
+      }
+      if (hasObjectIndex() != other.hasObjectIndex()) return false;
+      if (hasObjectIndex()) {
+        if (getObjectIndex()
+            != other.getObjectIndex()) return false;
+      }
+      if (hasReferenceIndex() != other.hasReferenceIndex()) return false;
+      if (hasReferenceIndex()) {
+        if (getReferenceIndex()
+            != other.getReferenceIndex()) return false;
+      }
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      if (hasConsistencyLevel()) {
+        hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER;
+        hash = (53 * hash) + consistencyLevel_;
+      }
+      if (hasObjectIndex()) {
+        hash = (37 * hash) + OBJECT_INDEX_FIELD_NUMBER;
+        hash = (53 * hash) + getObjectIndex();
+      }
+      if (hasReferenceIndex()) {
+        hash = (37 * hash) + REFERENCE_INDEX_FIELD_NUMBER;
+        hash = (53 * hash) + getReferenceIndex();
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamRequest}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamRequest)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequestOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        consistencyLevel_ = 0;
+        objectIndex_ = 0;
+        referenceIndex_ = 0;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamRequest_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest(this);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest result) {
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) != 0)) {
+          result.consistencyLevel_ = consistencyLevel_;
+          to_bitField0_ |= 0x00000001;
+        }
+        if (((from_bitField0_ & 0x00000002) != 0)) {
+          result.objectIndex_ = objectIndex_;
+          to_bitField0_ |= 0x00000002;
+        }
+        if (((from_bitField0_ & 0x00000004) != 0)) {
+          result.referenceIndex_ = referenceIndex_;
+          to_bitField0_ |= 0x00000004;
+        }
+        result.bitField0_ |= to_bitField0_;
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest.getDefaultInstance()) return this;
+        if (other.hasConsistencyLevel()) {
+          setConsistencyLevel(other.getConsistencyLevel());
+        }
+        if (other.hasObjectIndex()) {
+          setObjectIndex(other.getObjectIndex());
+        }
+        if (other.hasReferenceIndex()) {
+          setReferenceIndex(other.getReferenceIndex());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 8: {
+                consistencyLevel_ = input.readEnum();
+                bitField0_ |= 0x00000001;
+                break;
+              } // case 8
+              case 16: {
+                objectIndex_ = input.readInt32();
+                bitField0_ |= 0x00000002;
+                break;
+              } // case 16
+              case 24: {
+                referenceIndex_ = input.readInt32();
+                bitField0_ |= 0x00000004;
+                break;
+              } // case 24
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int bitField0_;
+
+      private int consistencyLevel_ = 0;
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @return Whether the consistencyLevel field is set.
+       */
+      @java.lang.Override public boolean hasConsistencyLevel() {
+        return ((bitField0_ & 0x00000001) != 0);
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @return The enum numeric value on the wire for consistencyLevel.
+       */
+      @java.lang.Override public int getConsistencyLevelValue() {
+        return consistencyLevel_;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @param value The enum numeric value on the wire for consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevelValue(int value) {
+        consistencyLevel_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @return The consistencyLevel.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_);
+        return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @param value The consistencyLevel to set.
+       * @return This builder for chaining.
+       */
+      public Builder setConsistencyLevel(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        bitField0_ |= 0x00000001;
+        consistencyLevel_ = value.getNumber();
+        onChanged();
+        return this;
+      }
+      /**
+       * optional .weaviate.v1.ConsistencyLevel consistency_level = 1;
+       * @return This builder for chaining.
+       */
+      public Builder clearConsistencyLevel() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        consistencyLevel_ = 0;
+        onChanged();
+        return this;
+      }
+
+      private int objectIndex_ ;
+      /**
+       * optional int32 object_index = 2;
+       * @return Whether the objectIndex field is set.
+       */
+      @java.lang.Override
+      public boolean hasObjectIndex() {
+        return ((bitField0_ & 0x00000002) != 0);
+      }
+      /**
+       * optional int32 object_index = 2;
+       * @return The objectIndex.
+       */
+      @java.lang.Override
+      public int getObjectIndex() {
+        return objectIndex_;
+      }
+      /**
+       * optional int32 object_index = 2;
+       * @param value The objectIndex to set.
+       * @return This builder for chaining.
+       */
+      public Builder setObjectIndex(int value) {
+
+        objectIndex_ = value;
+        bitField0_ |= 0x00000002;
+        onChanged();
+        return this;
+      }
+      /**
+       * optional int32 object_index = 2;
+       * @return This builder for chaining.
+       */
+      public Builder clearObjectIndex() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        objectIndex_ = 0;
+        onChanged();
+        return this;
+      }
+
+      private int referenceIndex_ ;
+      /**
+       * optional int32 reference_index = 3;
+       * @return Whether the referenceIndex field is set.
+       */
+      @java.lang.Override
+      public boolean hasReferenceIndex() {
+        return ((bitField0_ & 0x00000004) != 0);
+      }
+      /**
+       * optional int32 reference_index = 3;
+       * @return The referenceIndex.
+       */
+      @java.lang.Override
+      public int getReferenceIndex() {
+        return referenceIndex_;
+      }
+      /**
+       * optional int32 reference_index = 3;
+       * @param value The referenceIndex to set.
+       * @return This builder for chaining.
+       */
+      public Builder setReferenceIndex(int value) {
+
+        referenceIndex_ = value;
+        bitField0_ |= 0x00000004;
+        onChanged();
+        return this;
+      }
+      /**
+       * optional int32 reference_index = 3;
+       * @return This builder for chaining.
+       */
+      public Builder clearReferenceIndex() {
+        bitField0_ = (bitField0_ & ~0x00000004);
+        referenceIndex_ = 0;
+        onChanged();
+        return this;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamRequest)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamRequest)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchStreamRequest parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamRequest getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchStreamMessageOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * string stream_id = 1;
+     * @return The streamId.
+     */
+    java.lang.String getStreamId();
+    /**
+     * string stream_id = 1;
+     * @return The bytes for streamId.
+     */
+    com.google.protobuf.ByteString
+        getStreamIdBytes();
+
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     * @return Whether the error field is set.
+     */
+    boolean hasError();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     * @return The error.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getError();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     * @return Whether the start field is set.
+     */
+    boolean hasStart();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     * @return The start.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getStart();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     * @return Whether the stop field is set.
+     */
+    boolean hasStop();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     * @return The stop.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getStop();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     * @return Whether the shutdown field is set.
+     */
+    boolean hasShutdown();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     * @return The shutdown.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown();
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder();
+
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     * @return Whether the shuttingDown field is set.
+     */
+    boolean hasShuttingDown();
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     * @return The shuttingDown.
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown();
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder();
+
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.MessageCase getMessageCase();
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.BatchStreamMessage}
+   */
+  public static final class BatchStreamMessage extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage)
+      BatchStreamMessageOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use BatchStreamMessage.newBuilder() to construct.
+    private BatchStreamMessage(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private BatchStreamMessage() {
+      streamId_ = "";
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new BatchStreamMessage();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Builder.class);
+    }
+
+    public interface StartOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Start)
+        com.google.protobuf.MessageOrBuilder {
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage.Start}
+     */
+    public static final class Start extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Start)
+        StartOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Start.newBuilder() to construct.
+      private Start(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Start() {
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Start();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder.class);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) obj;
+
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchStreamMessage.Start}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Start)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start(this);
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance()) return this;
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Start)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Start)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Start parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface StopOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Stop)
+        com.google.protobuf.MessageOrBuilder {
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage.Stop}
+     */
+    public static final class Stop extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Stop)
+        StopOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Stop.newBuilder() to construct.
+      private Stop(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Stop() {
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Stop();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder.class);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) obj;
+
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchStreamMessage.Stop}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Stop)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop(this);
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance()) return this;
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Stop)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Stop)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Stop parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface ShutdownOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Shutdown)
+        com.google.protobuf.MessageOrBuilder {
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage.Shutdown}
+     */
+    public static final class Shutdown extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Shutdown)
+        ShutdownOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Shutdown.newBuilder() to construct.
+      private Shutdown(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Shutdown() {
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Shutdown();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder.class);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) obj;
+
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchStreamMessage.Shutdown}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Shutdown)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown(this);
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance()) return this;
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Shutdown)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Shutdown)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Shutdown parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface ShuttingDownOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.ShuttingDown)
+        com.google.protobuf.MessageOrBuilder {
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage.ShuttingDown}
+     */
+    public static final class ShuttingDown extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.ShuttingDown)
+        ShuttingDownOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use ShuttingDown.newBuilder() to construct.
+      private ShuttingDown(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private ShuttingDown() {
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new ShuttingDown();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder.class);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) obj;
+
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchStreamMessage.ShuttingDown}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.ShuttingDown)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown(this);
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance()) return this;
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.ShuttingDown)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.ShuttingDown)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public ShuttingDown parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public interface ErrorOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchStreamMessage.Error)
+        com.google.protobuf.MessageOrBuilder {
+
+      /**
+       * string error = 1;
+       * @return The error.
+       */
+      java.lang.String getError();
+      /**
+       * string error = 1;
+       * @return The bytes for error.
+       */
+      com.google.protobuf.ByteString
+          getErrorBytes();
+
+      /**
+       * int32 index = 2;
+       * @return The index.
+       */
+      int getIndex();
+
+      /**
+       * bool is_retriable = 3;
+       * @return The isRetriable.
+       */
+      boolean getIsRetriable();
+
+      /**
+       * bool is_object = 4;
+       * @return The isObject.
+       */
+      boolean getIsObject();
+
+      /**
+       * bool is_reference = 5;
+       * @return The isReference.
+       */
+      boolean getIsReference();
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage.Error}
+     */
+    public static final class Error extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:weaviate.v1.BatchStreamMessage.Error)
+        ErrorOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Error.newBuilder() to construct.
+      private Error(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+        super(builder);
+      }
+      private Error() {
+        error_ = "";
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Error();
+      }
+
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder.class);
+      }
+
+      public static final int ERROR_FIELD_NUMBER = 1;
+      @SuppressWarnings("serial")
+      private volatile java.lang.Object error_ = "";
+      /**
+       * string error = 1;
+       * @return The error.
+       */
+      @java.lang.Override
+      public java.lang.String getError() {
+        java.lang.Object ref = error_;
+        if (ref instanceof java.lang.String) {
+          return (java.lang.String) ref;
+        } else {
+          com.google.protobuf.ByteString bs = 
+              (com.google.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          error_ = s;
+          return s;
+        }
+      }
+      /**
+       * string error = 1;
+       * @return The bytes for error.
+       */
+      @java.lang.Override
+      public com.google.protobuf.ByteString
+          getErrorBytes() {
+        java.lang.Object ref = error_;
+        if (ref instanceof java.lang.String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          error_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+
+      public static final int INDEX_FIELD_NUMBER = 2;
+      private int index_ = 0;
+      /**
+       * int32 index = 2;
+       * @return The index.
+       */
+      @java.lang.Override
+      public int getIndex() {
+        return index_;
+      }
+
+      public static final int IS_RETRIABLE_FIELD_NUMBER = 3;
+      private boolean isRetriable_ = false;
+      /**
+       * bool is_retriable = 3;
+       * @return The isRetriable.
+       */
+      @java.lang.Override
+      public boolean getIsRetriable() {
+        return isRetriable_;
+      }
+
+      public static final int IS_OBJECT_FIELD_NUMBER = 4;
+      private boolean isObject_ = false;
+      /**
+       * bool is_object = 4;
+       * @return The isObject.
+       */
+      @java.lang.Override
+      public boolean getIsObject() {
+        return isObject_;
+      }
+
+      public static final int IS_REFERENCE_FIELD_NUMBER = 5;
+      private boolean isReference_ = false;
+      /**
+       * bool is_reference = 5;
+       * @return The isReference.
+       */
+      @java.lang.Override
+      public boolean getIsReference() {
+        return isReference_;
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) {
+          com.google.protobuf.GeneratedMessageV3.writeString(output, 1, error_);
+        }
+        if (index_ != 0) {
+          output.writeInt32(2, index_);
+        }
+        if (isRetriable_ != false) {
+          output.writeBool(3, isRetriable_);
+        }
+        if (isObject_ != false) {
+          output.writeBool(4, isObject_);
+        }
+        if (isReference_ != false) {
+          output.writeBool(5, isReference_);
+        }
+        getUnknownFields().writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) {
+          size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, error_);
+        }
+        if (index_ != 0) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeInt32Size(2, index_);
+        }
+        if (isRetriable_ != false) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeBoolSize(3, isRetriable_);
+        }
+        if (isObject_ != false) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeBoolSize(4, isObject_);
+        }
+        if (isReference_ != false) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeBoolSize(5, isReference_);
+        }
+        size += getUnknownFields().getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error)) {
+          return super.equals(obj);
+        }
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) obj;
+
+        if (!getError()
+            .equals(other.getError())) return false;
+        if (getIndex()
+            != other.getIndex()) return false;
+        if (getIsRetriable()
+            != other.getIsRetriable()) return false;
+        if (getIsObject()
+            != other.getIsObject()) return false;
+        if (getIsReference()
+            != other.getIsReference()) return false;
+        if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (37 * hash) + ERROR_FIELD_NUMBER;
+        hash = (53 * hash) + getError().hashCode();
+        hash = (37 * hash) + INDEX_FIELD_NUMBER;
+        hash = (53 * hash) + getIndex();
+        hash = (37 * hash) + IS_RETRIABLE_FIELD_NUMBER;
+        hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
+            getIsRetriable());
+        hash = (37 * hash) + IS_OBJECT_FIELD_NUMBER;
+        hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
+            getIsObject());
+        hash = (37 * hash) + IS_REFERENCE_FIELD_NUMBER;
+        hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
+            getIsReference());
+        hash = (29 * hash) + getUnknownFields().hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * Protobuf type {@code weaviate.v1.BatchStreamMessage.Error}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder implements
+          // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage.Error)
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder.class);
+        }
+
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.newBuilder()
+        private Builder() {
+
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          bitField0_ = 0;
+          error_ = "";
+          index_ = 0;
+          isRetriable_ = false;
+          isObject_ = false;
+          isReference_ = false;
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error(this);
+          if (bitField0_ != 0) { buildPartial0(result); }
+          onBuilt();
+          return result;
+        }
+
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error result) {
+          int from_bitField0_ = bitField0_;
+          if (((from_bitField0_ & 0x00000001) != 0)) {
+            result.error_ = error_;
+          }
+          if (((from_bitField0_ & 0x00000002) != 0)) {
+            result.index_ = index_;
+          }
+          if (((from_bitField0_ & 0x00000004) != 0)) {
+            result.isRetriable_ = isRetriable_;
+          }
+          if (((from_bitField0_ & 0x00000008) != 0)) {
+            result.isObject_ = isObject_;
+          }
+          if (((from_bitField0_ & 0x00000010) != 0)) {
+            result.isReference_ = isReference_;
+          }
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance()) return this;
+          if (!other.getError().isEmpty()) {
+            error_ = other.error_;
+            bitField0_ |= 0x00000001;
+            onChanged();
+          }
+          if (other.getIndex() != 0) {
+            setIndex(other.getIndex());
+          }
+          if (other.getIsRetriable() != false) {
+            setIsRetriable(other.getIsRetriable());
+          }
+          if (other.getIsObject() != false) {
+            setIsObject(other.getIsObject());
+          }
+          if (other.getIsReference() != false) {
+            setIsReference(other.getIsReference());
+          }
+          this.mergeUnknownFields(other.getUnknownFields());
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                case 10: {
+                  error_ = input.readStringRequireUtf8();
+                  bitField0_ |= 0x00000001;
+                  break;
+                } // case 10
+                case 16: {
+                  index_ = input.readInt32();
+                  bitField0_ |= 0x00000002;
+                  break;
+                } // case 16
+                case 24: {
+                  isRetriable_ = input.readBool();
+                  bitField0_ |= 0x00000004;
+                  break;
+                } // case 24
+                case 32: {
+                  isObject_ = input.readBool();
+                  bitField0_ |= 0x00000008;
+                  break;
+                } // case 32
+                case 40: {
+                  isReference_ = input.readBool();
+                  bitField0_ |= 0x00000010;
+                  break;
+                } // case 40
+                default: {
+                  if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                    done = true; // was an endgroup tag
+                  }
+                  break;
+                } // default:
+              } // switch (tag)
+            } // while (!done)
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.unwrapIOException();
+          } finally {
+            onChanged();
+          } // finally
+          return this;
+        }
+        private int bitField0_;
+
+        private java.lang.Object error_ = "";
+        /**
+         * string error = 1;
+         * @return The error.
+         */
+        public java.lang.String getError() {
+          java.lang.Object ref = error_;
+          if (!(ref instanceof java.lang.String)) {
+            com.google.protobuf.ByteString bs =
+                (com.google.protobuf.ByteString) ref;
+            java.lang.String s = bs.toStringUtf8();
+            error_ = s;
+            return s;
+          } else {
+            return (java.lang.String) ref;
+          }
+        }
+        /**
+         * string error = 1;
+         * @return The bytes for error.
+         */
+        public com.google.protobuf.ByteString
+            getErrorBytes() {
+          java.lang.Object ref = error_;
+          if (ref instanceof String) {
+            com.google.protobuf.ByteString b = 
+                com.google.protobuf.ByteString.copyFromUtf8(
+                    (java.lang.String) ref);
+            error_ = b;
+            return b;
+          } else {
+            return (com.google.protobuf.ByteString) ref;
+          }
+        }
+        /**
+         * string error = 1;
+         * @param value The error to set.
+         * @return This builder for chaining.
+         */
+        public Builder setError(
+            java.lang.String value) {
+          if (value == null) { throw new NullPointerException(); }
+          error_ = value;
+          bitField0_ |= 0x00000001;
+          onChanged();
+          return this;
+        }
+        /**
+         * string error = 1;
+         * @return This builder for chaining.
+         */
+        public Builder clearError() {
+          error_ = getDefaultInstance().getError();
+          bitField0_ = (bitField0_ & ~0x00000001);
+          onChanged();
+          return this;
+        }
+        /**
+         * string error = 1;
+         * @param value The bytes for error to set.
+         * @return This builder for chaining.
+         */
+        public Builder setErrorBytes(
+            com.google.protobuf.ByteString value) {
+          if (value == null) { throw new NullPointerException(); }
+          checkByteStringIsUtf8(value);
+          error_ = value;
+          bitField0_ |= 0x00000001;
+          onChanged();
+          return this;
+        }
+
+        private int index_ ;
+        /**
+         * int32 index = 2;
+         * @return The index.
+         */
+        @java.lang.Override
+        public int getIndex() {
+          return index_;
+        }
+        /**
+         * int32 index = 2;
+         * @param value The index to set.
+         * @return This builder for chaining.
+         */
+        public Builder setIndex(int value) {
+
+          index_ = value;
+          bitField0_ |= 0x00000002;
+          onChanged();
+          return this;
+        }
+        /**
+         * int32 index = 2;
+         * @return This builder for chaining.
+         */
+        public Builder clearIndex() {
+          bitField0_ = (bitField0_ & ~0x00000002);
+          index_ = 0;
+          onChanged();
+          return this;
+        }
+
+        private boolean isRetriable_ ;
+        /**
+         * bool is_retriable = 3;
+         * @return The isRetriable.
+         */
+        @java.lang.Override
+        public boolean getIsRetriable() {
+          return isRetriable_;
+        }
+        /**
+         * bool is_retriable = 3;
+         * @param value The isRetriable to set.
+         * @return This builder for chaining.
+         */
+        public Builder setIsRetriable(boolean value) {
+
+          isRetriable_ = value;
+          bitField0_ |= 0x00000004;
+          onChanged();
+          return this;
+        }
+        /**
+         * bool is_retriable = 3;
+         * @return This builder for chaining.
+         */
+        public Builder clearIsRetriable() {
+          bitField0_ = (bitField0_ & ~0x00000004);
+          isRetriable_ = false;
+          onChanged();
+          return this;
+        }
+
+        private boolean isObject_ ;
+        /**
+         * bool is_object = 4;
+         * @return The isObject.
+         */
+        @java.lang.Override
+        public boolean getIsObject() {
+          return isObject_;
+        }
+        /**
+         * bool is_object = 4;
+         * @param value The isObject to set.
+         * @return This builder for chaining.
+         */
+        public Builder setIsObject(boolean value) {
+
+          isObject_ = value;
+          bitField0_ |= 0x00000008;
+          onChanged();
+          return this;
+        }
+        /**
+         * bool is_object = 4;
+         * @return This builder for chaining.
+         */
+        public Builder clearIsObject() {
+          bitField0_ = (bitField0_ & ~0x00000008);
+          isObject_ = false;
+          onChanged();
+          return this;
+        }
+
+        private boolean isReference_ ;
+        /**
+         * bool is_reference = 5;
+         * @return The isReference.
+         */
+        @java.lang.Override
+        public boolean getIsReference() {
+          return isReference_;
+        }
+        /**
+         * bool is_reference = 5;
+         * @param value The isReference to set.
+         * @return This builder for chaining.
+         */
+        public Builder setIsReference(boolean value) {
+
+          isReference_ = value;
+          bitField0_ |= 0x00000010;
+          onChanged();
+          return this;
+        }
+        /**
+         * bool is_reference = 5;
+         * @return This builder for chaining.
+         */
+        public Builder clearIsReference() {
+          bitField0_ = (bitField0_ & ~0x00000010);
+          isReference_ = false;
+          onChanged();
+          return this;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage.Error)
+      }
+
+      // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage.Error)
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error();
+      }
+
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser
+          PARSER = new com.google.protobuf.AbstractParser() {
+        @java.lang.Override
+        public Error parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          Builder builder = newBuilder();
+          try {
+            builder.mergeFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(builder.buildPartial());
+          } catch (com.google.protobuf.UninitializedMessageException e) {
+            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(e)
+                .setUnfinishedMessage(builder.buildPartial());
+          }
+          return builder.buildPartial();
+        }
+      };
+
+      public static com.google.protobuf.Parser parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    private int messageCase_ = 0;
+    @SuppressWarnings("serial")
+    private java.lang.Object message_;
+    public enum MessageCase
+        implements com.google.protobuf.Internal.EnumLite,
+            com.google.protobuf.AbstractMessage.InternalOneOfEnum {
+      ERROR(2),
+      START(3),
+      STOP(4),
+      SHUTDOWN(5),
+      SHUTTING_DOWN(6),
+      MESSAGE_NOT_SET(0);
+      private final int value;
+      private MessageCase(int value) {
+        this.value = value;
+      }
+      /**
+       * @param value The number of the enum to look for.
+       * @return The enum associated with the given number.
+       * @deprecated Use {@link #forNumber(int)} instead.
+       */
+      @java.lang.Deprecated
+      public static MessageCase valueOf(int value) {
+        return forNumber(value);
+      }
+
+      public static MessageCase forNumber(int value) {
+        switch (value) {
+          case 2: return ERROR;
+          case 3: return START;
+          case 4: return STOP;
+          case 5: return SHUTDOWN;
+          case 6: return SHUTTING_DOWN;
+          case 0: return MESSAGE_NOT_SET;
+          default: return null;
+        }
+      }
+      public int getNumber() {
+        return this.value;
+      }
+    };
+
+    public MessageCase
+    getMessageCase() {
+      return MessageCase.forNumber(
+          messageCase_);
+    }
+
+    public static final int STREAM_ID_FIELD_NUMBER = 1;
+    @SuppressWarnings("serial")
+    private volatile java.lang.Object streamId_ = "";
+    /**
+     * string stream_id = 1;
+     * @return The streamId.
+     */
+    @java.lang.Override
+    public java.lang.String getStreamId() {
+      java.lang.Object ref = streamId_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        com.google.protobuf.ByteString bs = 
+            (com.google.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        streamId_ = s;
+        return s;
+      }
+    }
+    /**
+     * string stream_id = 1;
+     * @return The bytes for streamId.
+     */
+    @java.lang.Override
+    public com.google.protobuf.ByteString
+        getStreamIdBytes() {
+      java.lang.Object ref = streamId_;
+      if (ref instanceof java.lang.String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        streamId_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int ERROR_FIELD_NUMBER = 2;
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     * @return Whether the error field is set.
+     */
+    @java.lang.Override
+    public boolean hasError() {
+      return messageCase_ == 2;
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     * @return The error.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getError() {
+      if (messageCase_ == 2) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Error error = 2;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder() {
+      if (messageCase_ == 2) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+    }
+
+    public static final int START_FIELD_NUMBER = 3;
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     * @return Whether the start field is set.
+     */
+    @java.lang.Override
+    public boolean hasStart() {
+      return messageCase_ == 3;
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     * @return The start.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getStart() {
+      if (messageCase_ == 3) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Start start = 3;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder() {
+      if (messageCase_ == 3) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+    }
+
+    public static final int STOP_FIELD_NUMBER = 4;
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     * @return Whether the stop field is set.
+     */
+    @java.lang.Override
+    public boolean hasStop() {
+      return messageCase_ == 4;
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     * @return The stop.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getStop() {
+      if (messageCase_ == 4) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder() {
+      if (messageCase_ == 4) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+    }
+
+    public static final int SHUTDOWN_FIELD_NUMBER = 5;
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     * @return Whether the shutdown field is set.
+     */
+    @java.lang.Override
+    public boolean hasShutdown() {
+      return messageCase_ == 5;
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     * @return The shutdown.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown() {
+      if (messageCase_ == 5) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder() {
+      if (messageCase_ == 5) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+    }
+
+    public static final int SHUTTING_DOWN_FIELD_NUMBER = 6;
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     * @return Whether the shuttingDown field is set.
+     */
+    @java.lang.Override
+    public boolean hasShuttingDown() {
+      return messageCase_ == 6;
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     * @return The shuttingDown.
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown() {
+      if (messageCase_ == 6) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+    }
+    /**
+     * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder() {
+      if (messageCase_ == 6) {
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_;
+      }
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) {
+        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, streamId_);
+      }
+      if (messageCase_ == 2) {
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_);
+      }
+      if (messageCase_ == 3) {
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_);
+      }
+      if (messageCase_ == 4) {
+        output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_);
+      }
+      if (messageCase_ == 5) {
+        output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_);
+      }
+      if (messageCase_ == 6) {
+        output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(streamId_)) {
+        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, streamId_);
+      }
+      if (messageCase_ == 2) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_);
+      }
+      if (messageCase_ == 3) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_);
+      }
+      if (messageCase_ == 4) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_);
+      }
+      if (messageCase_ == 5) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_);
+      }
+      if (messageCase_ == 6) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage) obj;
+
+      if (!getStreamId()
+          .equals(other.getStreamId())) return false;
+      if (!getMessageCase().equals(other.getMessageCase())) return false;
+      switch (messageCase_) {
+        case 2:
+          if (!getError()
+              .equals(other.getError())) return false;
+          break;
+        case 3:
+          if (!getStart()
+              .equals(other.getStart())) return false;
+          break;
+        case 4:
+          if (!getStop()
+              .equals(other.getStop())) return false;
+          break;
+        case 5:
+          if (!getShutdown()
+              .equals(other.getShutdown())) return false;
+          break;
+        case 6:
+          if (!getShuttingDown()
+              .equals(other.getShuttingDown())) return false;
+          break;
+        case 0:
+        default:
+      }
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      hash = (37 * hash) + STREAM_ID_FIELD_NUMBER;
+      hash = (53 * hash) + getStreamId().hashCode();
+      switch (messageCase_) {
+        case 2:
+          hash = (37 * hash) + ERROR_FIELD_NUMBER;
+          hash = (53 * hash) + getError().hashCode();
+          break;
+        case 3:
+          hash = (37 * hash) + START_FIELD_NUMBER;
+          hash = (53 * hash) + getStart().hashCode();
+          break;
+        case 4:
+          hash = (37 * hash) + STOP_FIELD_NUMBER;
+          hash = (53 * hash) + getStop().hashCode();
+          break;
+        case 5:
+          hash = (37 * hash) + SHUTDOWN_FIELD_NUMBER;
+          hash = (53 * hash) + getShutdown().hashCode();
+          break;
+        case 6:
+          hash = (37 * hash) + SHUTTING_DOWN_FIELD_NUMBER;
+          hash = (53 * hash) + getShuttingDown().hashCode();
+          break;
+        case 0:
+        default:
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.BatchStreamMessage}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchStreamMessage)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessageOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        streamId_ = "";
+        if (errorBuilder_ != null) {
+          errorBuilder_.clear();
+        }
+        if (startBuilder_ != null) {
+          startBuilder_.clear();
+        }
+        if (stopBuilder_ != null) {
+          stopBuilder_.clear();
+        }
+        if (shutdownBuilder_ != null) {
+          shutdownBuilder_.clear();
+        }
+        if (shuttingDownBuilder_ != null) {
+          shuttingDownBuilder_.clear();
+        }
+        messageCase_ = 0;
+        message_ = null;
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchStreamMessage_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage(this);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        buildPartialOneofs(result);
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage result) {
+        int from_bitField0_ = bitField0_;
+        if (((from_bitField0_ & 0x00000001) != 0)) {
+          result.streamId_ = streamId_;
+        }
+      }
+
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage result) {
+        result.messageCase_ = messageCase_;
+        result.message_ = this.message_;
+        if (messageCase_ == 2 &&
+            errorBuilder_ != null) {
+          result.message_ = errorBuilder_.build();
+        }
+        if (messageCase_ == 3 &&
+            startBuilder_ != null) {
+          result.message_ = startBuilder_.build();
+        }
+        if (messageCase_ == 4 &&
+            stopBuilder_ != null) {
+          result.message_ = stopBuilder_.build();
+        }
+        if (messageCase_ == 5 &&
+            shutdownBuilder_ != null) {
+          result.message_ = shutdownBuilder_.build();
+        }
+        if (messageCase_ == 6 &&
+            shuttingDownBuilder_ != null) {
+          result.message_ = shuttingDownBuilder_.build();
+        }
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.getDefaultInstance()) return this;
+        if (!other.getStreamId().isEmpty()) {
+          streamId_ = other.streamId_;
+          bitField0_ |= 0x00000001;
+          onChanged();
+        }
+        switch (other.getMessageCase()) {
+          case ERROR: {
+            mergeError(other.getError());
+            break;
+          }
+          case START: {
+            mergeStart(other.getStart());
+            break;
+          }
+          case STOP: {
+            mergeStop(other.getStop());
+            break;
+          }
+          case SHUTDOWN: {
+            mergeShutdown(other.getShutdown());
+            break;
+          }
+          case SHUTTING_DOWN: {
+            mergeShuttingDown(other.getShuttingDown());
+            break;
+          }
+          case MESSAGE_NOT_SET: {
+            break;
+          }
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 10: {
+                streamId_ = input.readStringRequireUtf8();
+                bitField0_ |= 0x00000001;
+                break;
+              } // case 10
+              case 18: {
+                input.readMessage(
+                    getErrorFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 2;
+                break;
+              } // case 18
+              case 26: {
+                input.readMessage(
+                    getStartFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 3;
+                break;
+              } // case 26
+              case 34: {
+                input.readMessage(
+                    getStopFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 4;
+                break;
+              } // case 34
+              case 42: {
+                input.readMessage(
+                    getShutdownFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 5;
+                break;
+              } // case 42
+              case 50: {
+                input.readMessage(
+                    getShuttingDownFieldBuilder().getBuilder(),
+                    extensionRegistry);
+                messageCase_ = 6;
+                break;
+              } // case 50
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int messageCase_ = 0;
+      private java.lang.Object message_;
+      public MessageCase
+          getMessageCase() {
+        return MessageCase.forNumber(
+            messageCase_);
+      }
+
+      public Builder clearMessage() {
+        messageCase_ = 0;
+        message_ = null;
+        onChanged();
+        return this;
+      }
+
+      private int bitField0_;
+
+      private java.lang.Object streamId_ = "";
+      /**
+       * string stream_id = 1;
+       * @return The streamId.
+       */
+      public java.lang.String getStreamId() {
+        java.lang.Object ref = streamId_;
+        if (!(ref instanceof java.lang.String)) {
+          com.google.protobuf.ByteString bs =
+              (com.google.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          streamId_ = s;
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * string stream_id = 1;
+       * @return The bytes for streamId.
+       */
+      public com.google.protobuf.ByteString
+          getStreamIdBytes() {
+        java.lang.Object ref = streamId_;
+        if (ref instanceof String) {
+          com.google.protobuf.ByteString b = 
+              com.google.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          streamId_ = b;
+          return b;
+        } else {
+          return (com.google.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * string stream_id = 1;
+       * @param value The streamId to set.
+       * @return This builder for chaining.
+       */
+      public Builder setStreamId(
+          java.lang.String value) {
+        if (value == null) { throw new NullPointerException(); }
+        streamId_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+      /**
+       * string stream_id = 1;
+       * @return This builder for chaining.
+       */
+      public Builder clearStreamId() {
+        streamId_ = getDefaultInstance().getStreamId();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        onChanged();
+        return this;
+      }
+      /**
+       * string stream_id = 1;
+       * @param value The bytes for streamId to set.
+       * @return This builder for chaining.
+       */
+      public Builder setStreamIdBytes(
+          com.google.protobuf.ByteString value) {
+        if (value == null) { throw new NullPointerException(); }
+        checkByteStringIsUtf8(value);
+        streamId_ = value;
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return this;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder> errorBuilder_;
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       * @return Whether the error field is set.
+       */
+      @java.lang.Override
+      public boolean hasError() {
+        return messageCase_ == 2;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       * @return The error.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error getError() {
+        if (errorBuilder_ == null) {
+          if (messageCase_ == 2) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+        } else {
+          if (messageCase_ == 2) {
+            return errorBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      public Builder setError(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error value) {
+        if (errorBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          errorBuilder_.setMessage(value);
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      public Builder setError(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder builderForValue) {
+        if (errorBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          errorBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      public Builder mergeError(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error value) {
+        if (errorBuilder_ == null) {
+          if (messageCase_ == 2 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 2) {
+            errorBuilder_.mergeFrom(value);
+          } else {
+            errorBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 2;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      public Builder clearError() {
+        if (errorBuilder_ == null) {
+          if (messageCase_ == 2) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 2) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          errorBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder getErrorBuilder() {
+        return getErrorFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder getErrorOrBuilder() {
+        if ((messageCase_ == 2) && (errorBuilder_ != null)) {
+          return errorBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 2) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Error error = 2;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder> 
+          getErrorFieldBuilder() {
+        if (errorBuilder_ == null) {
+          if (!(messageCase_ == 2)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.getDefaultInstance();
+          }
+          errorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ErrorOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Error) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 2;
+        onChanged();
+        return errorBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder> startBuilder_;
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       * @return Whether the start field is set.
+       */
+      @java.lang.Override
+      public boolean hasStart() {
+        return messageCase_ == 3;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       * @return The start.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start getStart() {
+        if (startBuilder_ == null) {
+          if (messageCase_ == 3) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+        } else {
+          if (messageCase_ == 3) {
+            return startBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      public Builder setStart(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start value) {
+        if (startBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          startBuilder_.setMessage(value);
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      public Builder setStart(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder builderForValue) {
+        if (startBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          startBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      public Builder mergeStart(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start value) {
+        if (startBuilder_ == null) {
+          if (messageCase_ == 3 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 3) {
+            startBuilder_.mergeFrom(value);
+          } else {
+            startBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 3;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      public Builder clearStart() {
+        if (startBuilder_ == null) {
+          if (messageCase_ == 3) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 3) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          startBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder getStartBuilder() {
+        return getStartFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder getStartOrBuilder() {
+        if ((messageCase_ == 3) && (startBuilder_ != null)) {
+          return startBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 3) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Start start = 3;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder> 
+          getStartFieldBuilder() {
+        if (startBuilder_ == null) {
+          if (!(messageCase_ == 3)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.getDefaultInstance();
+          }
+          startBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StartOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Start) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 3;
+        onChanged();
+        return startBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder> stopBuilder_;
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       * @return Whether the stop field is set.
+       */
+      @java.lang.Override
+      public boolean hasStop() {
+        return messageCase_ == 4;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       * @return The stop.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop getStop() {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+        } else {
+          if (messageCase_ == 4) {
+            return stopBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      public Builder setStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop value) {
+        if (stopBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          stopBuilder_.setMessage(value);
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      public Builder setStop(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder builderForValue) {
+        if (stopBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          stopBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      public Builder mergeStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop value) {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 4) {
+            stopBuilder_.mergeFrom(value);
+          } else {
+            stopBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 4;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      public Builder clearStop() {
+        if (stopBuilder_ == null) {
+          if (messageCase_ == 4) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 4) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          stopBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder getStopBuilder() {
+        return getStopFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder getStopOrBuilder() {
+        if ((messageCase_ == 4) && (stopBuilder_ != null)) {
+          return stopBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 4) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Stop stop = 4;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder> 
+          getStopFieldBuilder() {
+        if (stopBuilder_ == null) {
+          if (!(messageCase_ == 4)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.getDefaultInstance();
+          }
+          stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.StopOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Stop) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 4;
+        onChanged();
+        return stopBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder> shutdownBuilder_;
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       * @return Whether the shutdown field is set.
+       */
+      @java.lang.Override
+      public boolean hasShutdown() {
+        return messageCase_ == 5;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       * @return The shutdown.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown getShutdown() {
+        if (shutdownBuilder_ == null) {
+          if (messageCase_ == 5) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+        } else {
+          if (messageCase_ == 5) {
+            return shutdownBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      public Builder setShutdown(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown value) {
+        if (shutdownBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          shutdownBuilder_.setMessage(value);
+        }
+        messageCase_ = 5;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      public Builder setShutdown(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder builderForValue) {
+        if (shutdownBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          shutdownBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 5;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      public Builder mergeShutdown(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown value) {
+        if (shutdownBuilder_ == null) {
+          if (messageCase_ == 5 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 5) {
+            shutdownBuilder_.mergeFrom(value);
+          } else {
+            shutdownBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 5;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      public Builder clearShutdown() {
+        if (shutdownBuilder_ == null) {
+          if (messageCase_ == 5) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 5) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          shutdownBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder getShutdownBuilder() {
+        return getShutdownFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder getShutdownOrBuilder() {
+        if ((messageCase_ == 5) && (shutdownBuilder_ != null)) {
+          return shutdownBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 5) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.Shutdown shutdown = 5;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder> 
+          getShutdownFieldBuilder() {
+        if (shutdownBuilder_ == null) {
+          if (!(messageCase_ == 5)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.getDefaultInstance();
+          }
+          shutdownBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShutdownOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.Shutdown) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 5;
+        onChanged();
+        return shutdownBuilder_;
+      }
+
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder> shuttingDownBuilder_;
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       * @return Whether the shuttingDown field is set.
+       */
+      @java.lang.Override
+      public boolean hasShuttingDown() {
+        return messageCase_ == 6;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       * @return The shuttingDown.
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown getShuttingDown() {
+        if (shuttingDownBuilder_ == null) {
+          if (messageCase_ == 6) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+        } else {
+          if (messageCase_ == 6) {
+            return shuttingDownBuilder_.getMessage();
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      public Builder setShuttingDown(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown value) {
+        if (shuttingDownBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          message_ = value;
+          onChanged();
+        } else {
+          shuttingDownBuilder_.setMessage(value);
+        }
+        messageCase_ = 6;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      public Builder setShuttingDown(
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder builderForValue) {
+        if (shuttingDownBuilder_ == null) {
+          message_ = builderForValue.build();
+          onChanged();
+        } else {
+          shuttingDownBuilder_.setMessage(builderForValue.build());
+        }
+        messageCase_ = 6;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      public Builder mergeShuttingDown(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown value) {
+        if (shuttingDownBuilder_ == null) {
+          if (messageCase_ == 6 &&
+              message_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance()) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_)
+                .mergeFrom(value).buildPartial();
+          } else {
+            message_ = value;
+          }
+          onChanged();
+        } else {
+          if (messageCase_ == 6) {
+            shuttingDownBuilder_.mergeFrom(value);
+          } else {
+            shuttingDownBuilder_.setMessage(value);
+          }
+        }
+        messageCase_ = 6;
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      public Builder clearShuttingDown() {
+        if (shuttingDownBuilder_ == null) {
+          if (messageCase_ == 6) {
+            messageCase_ = 0;
+            message_ = null;
+            onChanged();
+          }
+        } else {
+          if (messageCase_ == 6) {
+            messageCase_ = 0;
+            message_ = null;
+          }
+          shuttingDownBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder getShuttingDownBuilder() {
+        return getShuttingDownFieldBuilder().getBuilder();
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder getShuttingDownOrBuilder() {
+        if ((messageCase_ == 6) && (shuttingDownBuilder_ != null)) {
+          return shuttingDownBuilder_.getMessageOrBuilder();
+        } else {
+          if (messageCase_ == 6) {
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_;
+          }
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+        }
+      }
+      /**
+       * .weaviate.v1.BatchStreamMessage.ShuttingDown shutting_down = 6;
+       */
+      private com.google.protobuf.SingleFieldBuilderV3<
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder> 
+          getShuttingDownFieldBuilder() {
+        if (shuttingDownBuilder_ == null) {
+          if (!(messageCase_ == 6)) {
+            message_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.getDefaultInstance();
+          }
+          shuttingDownBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDownOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage.ShuttingDown) message_,
+                  getParentForChildren(),
+                  isClean());
+          message_ = null;
+        }
+        messageCase_ = 6;
+        onChanged();
+        return shuttingDownBuilder_;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchStreamMessage)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.BatchStreamMessage)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public BatchStreamMessage parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchStreamMessage getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface BatchObjectOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * string uuid = 1;
+     * @return The uuid.
+     */
+    java.lang.String getUuid();
+    /**
+     * string uuid = 1;
+     * @return The bytes for uuid.
+     */
+    com.google.protobuf.ByteString
+        getUuidBytes();
+
+    /**
+     * 
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return A list containing the vector. + */ + @java.lang.Deprecated java.util.List getVectorList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return The count of vector. + */ + @java.lang.Deprecated int getVectorCount(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated float getVector(int index); + + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return Whether the properties field is set. + */ + boolean hasProperties(); + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return The properties. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getProperties(); + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder(); + + /** + * string collection = 4; + * @return The collection. + */ + java.lang.String getCollection(); + /** + * string collection = 4; + * @return The bytes for collection. + */ + com.google.protobuf.ByteString + getCollectionBytes(); + + /** + * string tenant = 5; + * @return The tenant. + */ + java.lang.String getTenant(); + /** + * string tenant = 5; + * @return The bytes for tenant. + */ + com.google.protobuf.ByteString + getTenantBytes(); + + /** + * bytes vector_bytes = 6; + * @return The vectorBytes. + */ + com.google.protobuf.ByteString getVectorBytes(); + + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + java.util.List + getVectorsList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + int getVectorsCount(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + java.util.List + getVectorsOrBuilderList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.BatchObject} + */ + public static final class BatchObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject) + BatchObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchObject.newBuilder() to construct. + private BatchObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchObject() { + uuid_ = ""; + vector_ = emptyFloatList(); + collection_ = ""; + tenant_ = ""; + vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + vectors_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchObject(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder.class); + } + + public interface PropertiesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.Properties) + com.google.protobuf.MessageOrBuilder { + + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return Whether the nonRefProperties field is set. + */ + boolean hasNonRefProperties(); + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return The nonRefProperties. + */ + com.google.protobuf.Struct getNonRefProperties(); + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder(); + + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + java.util.List + getSingleTargetRefPropsList(); + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index); + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + int getSingleTargetRefPropsCount(); + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + java.util.List + getSingleTargetRefPropsOrBuilderList(); + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( + int index); + + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + java.util.List + getMultiTargetRefPropsList(); + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index); + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + int getMultiTargetRefPropsCount(); + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + java.util.List + getMultiTargetRefPropsOrBuilderList(); + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( + int index); + + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + java.util.List + getNumberArrayPropertiesList(); + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index); + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + int getNumberArrayPropertiesCount(); + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + java.util.List + getNumberArrayPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + java.util.List + getIntArrayPropertiesList(); + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index); + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + int getIntArrayPropertiesCount(); + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + java.util.List + getIntArrayPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + java.util.List + getTextArrayPropertiesList(); + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index); + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + int getTextArrayPropertiesCount(); + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + java.util.List + getTextArrayPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + java.util.List + getBooleanArrayPropertiesList(); + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index); + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + int getBooleanArrayPropertiesCount(); + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + java.util.List + getBooleanArrayPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + java.util.List + getObjectPropertiesList(); + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index); + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + int getObjectPropertiesCount(); + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + java.util.List + getObjectPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + java.util.List + getObjectArrayPropertiesList(); + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index); + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + int getObjectArrayPropertiesCount(); + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + java.util.List + getObjectArrayPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( + int index); + + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @return A list containing the emptyListProps. + */ + java.util.List + getEmptyListPropsList(); + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @return The count of emptyListProps. + */ + int getEmptyListPropsCount(); + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the element to return. + * @return The emptyListProps at the given index. + */ + java.lang.String getEmptyListProps(int index); + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the value to return. + * @return The bytes of the emptyListProps at the given index. + */ + com.google.protobuf.ByteString + getEmptyListPropsBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.Properties} + */ + public static final class Properties extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.Properties) + PropertiesOrBuilder { + private static final long serialVersionUID = 0L; + // Use Properties.newBuilder() to construct. + private Properties(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Properties() { + singleTargetRefProps_ = java.util.Collections.emptyList(); + multiTargetRefProps_ = java.util.Collections.emptyList(); + numberArrayProperties_ = java.util.Collections.emptyList(); + intArrayProperties_ = java.util.Collections.emptyList(); + textArrayProperties_ = java.util.Collections.emptyList(); + booleanArrayProperties_ = java.util.Collections.emptyList(); + objectProperties_ = java.util.Collections.emptyList(); + objectArrayProperties_ = java.util.Collections.emptyList(); + emptyListProps_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Properties(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder.class); + } + + private int bitField0_; + public static final int NON_REF_PROPERTIES_FIELD_NUMBER = 1; + private com.google.protobuf.Struct nonRefProperties_; + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return Whether the nonRefProperties field is set. + */ + @java.lang.Override + public boolean hasNonRefProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return The nonRefProperties. + */ + @java.lang.Override + public com.google.protobuf.Struct getNonRefProperties() { + return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + @java.lang.Override + public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() { + return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; + } + + public static final int SINGLE_TARGET_REF_PROPS_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List singleTargetRefProps_; + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + @java.lang.Override + public java.util.List getSingleTargetRefPropsList() { + return singleTargetRefProps_; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + @java.lang.Override + public java.util.List + getSingleTargetRefPropsOrBuilderList() { + return singleTargetRefProps_; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + @java.lang.Override + public int getSingleTargetRefPropsCount() { + return singleTargetRefProps_.size(); + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index) { + return singleTargetRefProps_.get(index); + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( + int index) { + return singleTargetRefProps_.get(index); + } + + public static final int MULTI_TARGET_REF_PROPS_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private java.util.List multiTargetRefProps_; + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + @java.lang.Override + public java.util.List getMultiTargetRefPropsList() { + return multiTargetRefProps_; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + @java.lang.Override + public java.util.List + getMultiTargetRefPropsOrBuilderList() { + return multiTargetRefProps_; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + @java.lang.Override + public int getMultiTargetRefPropsCount() { + return multiTargetRefProps_.size(); + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index) { + return multiTargetRefProps_.get(index); + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( + int index) { + return multiTargetRefProps_.get(index); + } + + public static final int NUMBER_ARRAY_PROPERTIES_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private java.util.List numberArrayProperties_; + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + @java.lang.Override + public java.util.List getNumberArrayPropertiesList() { + return numberArrayProperties_; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + @java.lang.Override + public java.util.List + getNumberArrayPropertiesOrBuilderList() { + return numberArrayProperties_; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + @java.lang.Override + public int getNumberArrayPropertiesCount() { + return numberArrayProperties_.size(); + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) { + return numberArrayProperties_.get(index); + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( + int index) { + return numberArrayProperties_.get(index); + } + + public static final int INT_ARRAY_PROPERTIES_FIELD_NUMBER = 5; + @SuppressWarnings("serial") + private java.util.List intArrayProperties_; + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + @java.lang.Override + public java.util.List getIntArrayPropertiesList() { + return intArrayProperties_; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + @java.lang.Override + public java.util.List + getIntArrayPropertiesOrBuilderList() { + return intArrayProperties_; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + @java.lang.Override + public int getIntArrayPropertiesCount() { + return intArrayProperties_.size(); + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) { + return intArrayProperties_.get(index); + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( + int index) { + return intArrayProperties_.get(index); + } + + public static final int TEXT_ARRAY_PROPERTIES_FIELD_NUMBER = 6; + @SuppressWarnings("serial") + private java.util.List textArrayProperties_; + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + @java.lang.Override + public java.util.List getTextArrayPropertiesList() { + return textArrayProperties_; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + @java.lang.Override + public java.util.List + getTextArrayPropertiesOrBuilderList() { + return textArrayProperties_; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + @java.lang.Override + public int getTextArrayPropertiesCount() { + return textArrayProperties_.size(); + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) { + return textArrayProperties_.get(index); + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( + int index) { + return textArrayProperties_.get(index); + } + + public static final int BOOLEAN_ARRAY_PROPERTIES_FIELD_NUMBER = 7; + @SuppressWarnings("serial") + private java.util.List booleanArrayProperties_; + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + @java.lang.Override + public java.util.List getBooleanArrayPropertiesList() { + return booleanArrayProperties_; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + @java.lang.Override + public java.util.List + getBooleanArrayPropertiesOrBuilderList() { + return booleanArrayProperties_; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + @java.lang.Override + public int getBooleanArrayPropertiesCount() { + return booleanArrayProperties_.size(); + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) { + return booleanArrayProperties_.get(index); + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( + int index) { + return booleanArrayProperties_.get(index); + } + + public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 8; + @SuppressWarnings("serial") + private java.util.List objectProperties_; + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + @java.lang.Override + public java.util.List getObjectPropertiesList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + @java.lang.Override + public java.util.List + getObjectPropertiesOrBuilderList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + @java.lang.Override + public int getObjectPropertiesCount() { + return objectProperties_.size(); + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) { + return objectProperties_.get(index); + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( + int index) { + return objectProperties_.get(index); + } + + public static final int OBJECT_ARRAY_PROPERTIES_FIELD_NUMBER = 9; + @SuppressWarnings("serial") + private java.util.List objectArrayProperties_; + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + @java.lang.Override + public java.util.List getObjectArrayPropertiesList() { + return objectArrayProperties_; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + @java.lang.Override + public java.util.List + getObjectArrayPropertiesOrBuilderList() { + return objectArrayProperties_; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + @java.lang.Override + public int getObjectArrayPropertiesCount() { + return objectArrayProperties_.size(); + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) { + return objectArrayProperties_.get(index); + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( + int index) { + return objectArrayProperties_.get(index); + } + + public static final int EMPTY_LIST_PROPS_FIELD_NUMBER = 10; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList emptyListProps_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @return A list containing the emptyListProps. + */ + public com.google.protobuf.ProtocolStringList + getEmptyListPropsList() { + return emptyListProps_; + } + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @return The count of emptyListProps. + */ + public int getEmptyListPropsCount() { + return emptyListProps_.size(); + } + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the element to return. + * @return The emptyListProps at the given index. + */ + public java.lang.String getEmptyListProps(int index) { + return emptyListProps_.get(index); + } + /** + *
+       * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+       * Weaviate can get the datatype from its schema
+       * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the value to return. + * @return The bytes of the emptyListProps at the given index. + */ + public com.google.protobuf.ByteString + getEmptyListPropsBytes(int index) { + return emptyListProps_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getNonRefProperties()); + } + for (int i = 0; i < singleTargetRefProps_.size(); i++) { + output.writeMessage(2, singleTargetRefProps_.get(i)); + } + for (int i = 0; i < multiTargetRefProps_.size(); i++) { + output.writeMessage(3, multiTargetRefProps_.get(i)); + } + for (int i = 0; i < numberArrayProperties_.size(); i++) { + output.writeMessage(4, numberArrayProperties_.get(i)); + } + for (int i = 0; i < intArrayProperties_.size(); i++) { + output.writeMessage(5, intArrayProperties_.get(i)); + } + for (int i = 0; i < textArrayProperties_.size(); i++) { + output.writeMessage(6, textArrayProperties_.get(i)); + } + for (int i = 0; i < booleanArrayProperties_.size(); i++) { + output.writeMessage(7, booleanArrayProperties_.get(i)); + } + for (int i = 0; i < objectProperties_.size(); i++) { + output.writeMessage(8, objectProperties_.get(i)); + } + for (int i = 0; i < objectArrayProperties_.size(); i++) { + output.writeMessage(9, objectArrayProperties_.get(i)); + } + for (int i = 0; i < emptyListProps_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 10, emptyListProps_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getNonRefProperties()); + } + for (int i = 0; i < singleTargetRefProps_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, singleTargetRefProps_.get(i)); + } + for (int i = 0; i < multiTargetRefProps_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, multiTargetRefProps_.get(i)); + } + for (int i = 0; i < numberArrayProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, numberArrayProperties_.get(i)); + } + for (int i = 0; i < intArrayProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, intArrayProperties_.get(i)); + } + for (int i = 0; i < textArrayProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, textArrayProperties_.get(i)); + } + for (int i = 0; i < booleanArrayProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, booleanArrayProperties_.get(i)); + } + for (int i = 0; i < objectProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, objectProperties_.get(i)); + } + for (int i = 0; i < objectArrayProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, objectArrayProperties_.get(i)); + } + { + int dataSize = 0; + for (int i = 0; i < emptyListProps_.size(); i++) { + dataSize += computeStringSizeNoTag(emptyListProps_.getRaw(i)); + } + size += dataSize; + size += 1 * getEmptyListPropsList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties) obj; + + if (hasNonRefProperties() != other.hasNonRefProperties()) return false; + if (hasNonRefProperties()) { + if (!getNonRefProperties() + .equals(other.getNonRefProperties())) return false; + } + if (!getSingleTargetRefPropsList() + .equals(other.getSingleTargetRefPropsList())) return false; + if (!getMultiTargetRefPropsList() + .equals(other.getMultiTargetRefPropsList())) return false; + if (!getNumberArrayPropertiesList() + .equals(other.getNumberArrayPropertiesList())) return false; + if (!getIntArrayPropertiesList() + .equals(other.getIntArrayPropertiesList())) return false; + if (!getTextArrayPropertiesList() + .equals(other.getTextArrayPropertiesList())) return false; + if (!getBooleanArrayPropertiesList() + .equals(other.getBooleanArrayPropertiesList())) return false; + if (!getObjectPropertiesList() + .equals(other.getObjectPropertiesList())) return false; + if (!getObjectArrayPropertiesList() + .equals(other.getObjectArrayPropertiesList())) return false; + if (!getEmptyListPropsList() + .equals(other.getEmptyListPropsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasNonRefProperties()) { + hash = (37 * hash) + NON_REF_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getNonRefProperties().hashCode(); + } + if (getSingleTargetRefPropsCount() > 0) { + hash = (37 * hash) + SINGLE_TARGET_REF_PROPS_FIELD_NUMBER; + hash = (53 * hash) + getSingleTargetRefPropsList().hashCode(); + } + if (getMultiTargetRefPropsCount() > 0) { + hash = (37 * hash) + MULTI_TARGET_REF_PROPS_FIELD_NUMBER; + hash = (53 * hash) + getMultiTargetRefPropsList().hashCode(); + } + if (getNumberArrayPropertiesCount() > 0) { + hash = (37 * hash) + NUMBER_ARRAY_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getNumberArrayPropertiesList().hashCode(); + } + if (getIntArrayPropertiesCount() > 0) { + hash = (37 * hash) + INT_ARRAY_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getIntArrayPropertiesList().hashCode(); + } + if (getTextArrayPropertiesCount() > 0) { + hash = (37 * hash) + TEXT_ARRAY_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getTextArrayPropertiesList().hashCode(); + } + if (getBooleanArrayPropertiesCount() > 0) { + hash = (37 * hash) + BOOLEAN_ARRAY_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getBooleanArrayPropertiesList().hashCode(); + } + if (getObjectPropertiesCount() > 0) { + hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getObjectPropertiesList().hashCode(); + } + if (getObjectArrayPropertiesCount() > 0) { + hash = (37 * hash) + OBJECT_ARRAY_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getObjectArrayPropertiesList().hashCode(); + } + if (getEmptyListPropsCount() > 0) { + hash = (37 * hash) + EMPTY_LIST_PROPS_FIELD_NUMBER; + hash = (53 * hash) + getEmptyListPropsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.Properties} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.Properties) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getNonRefPropertiesFieldBuilder(); + getSingleTargetRefPropsFieldBuilder(); + getMultiTargetRefPropsFieldBuilder(); + getNumberArrayPropertiesFieldBuilder(); + getIntArrayPropertiesFieldBuilder(); + getTextArrayPropertiesFieldBuilder(); + getBooleanArrayPropertiesFieldBuilder(); + getObjectPropertiesFieldBuilder(); + getObjectArrayPropertiesFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + nonRefProperties_ = null; + if (nonRefPropertiesBuilder_ != null) { + nonRefPropertiesBuilder_.dispose(); + nonRefPropertiesBuilder_ = null; + } + if (singleTargetRefPropsBuilder_ == null) { + singleTargetRefProps_ = java.util.Collections.emptyList(); + } else { + singleTargetRefProps_ = null; + singleTargetRefPropsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (multiTargetRefPropsBuilder_ == null) { + multiTargetRefProps_ = java.util.Collections.emptyList(); + } else { + multiTargetRefProps_ = null; + multiTargetRefPropsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (numberArrayPropertiesBuilder_ == null) { + numberArrayProperties_ = java.util.Collections.emptyList(); + } else { + numberArrayProperties_ = null; + numberArrayPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (intArrayPropertiesBuilder_ == null) { + intArrayProperties_ = java.util.Collections.emptyList(); + } else { + intArrayProperties_ = null; + intArrayPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (textArrayPropertiesBuilder_ == null) { + textArrayProperties_ = java.util.Collections.emptyList(); + } else { + textArrayProperties_ = null; + textArrayPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + if (booleanArrayPropertiesBuilder_ == null) { + booleanArrayProperties_ = java.util.Collections.emptyList(); + } else { + booleanArrayProperties_ = null; + booleanArrayPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + } else { + objectProperties_ = null; + objectPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + if (objectArrayPropertiesBuilder_ == null) { + objectArrayProperties_ = java.util.Collections.emptyList(); + } else { + objectArrayProperties_ = null; + objectArrayPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + emptyListProps_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_Properties_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties result) { + if (singleTargetRefPropsBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + singleTargetRefProps_ = java.util.Collections.unmodifiableList(singleTargetRefProps_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.singleTargetRefProps_ = singleTargetRefProps_; + } else { + result.singleTargetRefProps_ = singleTargetRefPropsBuilder_.build(); + } + if (multiTargetRefPropsBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + multiTargetRefProps_ = java.util.Collections.unmodifiableList(multiTargetRefProps_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.multiTargetRefProps_ = multiTargetRefProps_; + } else { + result.multiTargetRefProps_ = multiTargetRefPropsBuilder_.build(); + } + if (numberArrayPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0)) { + numberArrayProperties_ = java.util.Collections.unmodifiableList(numberArrayProperties_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.numberArrayProperties_ = numberArrayProperties_; + } else { + result.numberArrayProperties_ = numberArrayPropertiesBuilder_.build(); + } + if (intArrayPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0)) { + intArrayProperties_ = java.util.Collections.unmodifiableList(intArrayProperties_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.intArrayProperties_ = intArrayProperties_; + } else { + result.intArrayProperties_ = intArrayPropertiesBuilder_.build(); + } + if (textArrayPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0)) { + textArrayProperties_ = java.util.Collections.unmodifiableList(textArrayProperties_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.textArrayProperties_ = textArrayProperties_; + } else { + result.textArrayProperties_ = textArrayPropertiesBuilder_.build(); + } + if (booleanArrayPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0)) { + booleanArrayProperties_ = java.util.Collections.unmodifiableList(booleanArrayProperties_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.booleanArrayProperties_ = booleanArrayProperties_; + } else { + result.booleanArrayProperties_ = booleanArrayPropertiesBuilder_.build(); + } + if (objectPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0)) { + objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.objectProperties_ = objectProperties_; + } else { + result.objectProperties_ = objectPropertiesBuilder_.build(); + } + if (objectArrayPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000100) != 0)) { + objectArrayProperties_ = java.util.Collections.unmodifiableList(objectArrayProperties_); + bitField0_ = (bitField0_ & ~0x00000100); + } + result.objectArrayProperties_ = objectArrayProperties_; + } else { + result.objectArrayProperties_ = objectArrayPropertiesBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties result) { + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.nonRefProperties_ = nonRefPropertiesBuilder_ == null + ? nonRefProperties_ + : nonRefPropertiesBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + emptyListProps_.makeImmutable(); + result.emptyListProps_ = emptyListProps_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance()) return this; + if (other.hasNonRefProperties()) { + mergeNonRefProperties(other.getNonRefProperties()); + } + if (singleTargetRefPropsBuilder_ == null) { + if (!other.singleTargetRefProps_.isEmpty()) { + if (singleTargetRefProps_.isEmpty()) { + singleTargetRefProps_ = other.singleTargetRefProps_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.addAll(other.singleTargetRefProps_); + } + onChanged(); + } + } else { + if (!other.singleTargetRefProps_.isEmpty()) { + if (singleTargetRefPropsBuilder_.isEmpty()) { + singleTargetRefPropsBuilder_.dispose(); + singleTargetRefPropsBuilder_ = null; + singleTargetRefProps_ = other.singleTargetRefProps_; + bitField0_ = (bitField0_ & ~0x00000002); + singleTargetRefPropsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getSingleTargetRefPropsFieldBuilder() : null; + } else { + singleTargetRefPropsBuilder_.addAllMessages(other.singleTargetRefProps_); + } + } + } + if (multiTargetRefPropsBuilder_ == null) { + if (!other.multiTargetRefProps_.isEmpty()) { + if (multiTargetRefProps_.isEmpty()) { + multiTargetRefProps_ = other.multiTargetRefProps_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.addAll(other.multiTargetRefProps_); + } + onChanged(); + } + } else { + if (!other.multiTargetRefProps_.isEmpty()) { + if (multiTargetRefPropsBuilder_.isEmpty()) { + multiTargetRefPropsBuilder_.dispose(); + multiTargetRefPropsBuilder_ = null; + multiTargetRefProps_ = other.multiTargetRefProps_; + bitField0_ = (bitField0_ & ~0x00000004); + multiTargetRefPropsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getMultiTargetRefPropsFieldBuilder() : null; + } else { + multiTargetRefPropsBuilder_.addAllMessages(other.multiTargetRefProps_); + } + } + } + if (numberArrayPropertiesBuilder_ == null) { + if (!other.numberArrayProperties_.isEmpty()) { + if (numberArrayProperties_.isEmpty()) { + numberArrayProperties_ = other.numberArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.addAll(other.numberArrayProperties_); + } + onChanged(); + } + } else { + if (!other.numberArrayProperties_.isEmpty()) { + if (numberArrayPropertiesBuilder_.isEmpty()) { + numberArrayPropertiesBuilder_.dispose(); + numberArrayPropertiesBuilder_ = null; + numberArrayProperties_ = other.numberArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000008); + numberArrayPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getNumberArrayPropertiesFieldBuilder() : null; + } else { + numberArrayPropertiesBuilder_.addAllMessages(other.numberArrayProperties_); + } + } + } + if (intArrayPropertiesBuilder_ == null) { + if (!other.intArrayProperties_.isEmpty()) { + if (intArrayProperties_.isEmpty()) { + intArrayProperties_ = other.intArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.addAll(other.intArrayProperties_); + } + onChanged(); + } + } else { + if (!other.intArrayProperties_.isEmpty()) { + if (intArrayPropertiesBuilder_.isEmpty()) { + intArrayPropertiesBuilder_.dispose(); + intArrayPropertiesBuilder_ = null; + intArrayProperties_ = other.intArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000010); + intArrayPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getIntArrayPropertiesFieldBuilder() : null; + } else { + intArrayPropertiesBuilder_.addAllMessages(other.intArrayProperties_); + } + } + } + if (textArrayPropertiesBuilder_ == null) { + if (!other.textArrayProperties_.isEmpty()) { + if (textArrayProperties_.isEmpty()) { + textArrayProperties_ = other.textArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.addAll(other.textArrayProperties_); + } + onChanged(); + } + } else { + if (!other.textArrayProperties_.isEmpty()) { + if (textArrayPropertiesBuilder_.isEmpty()) { + textArrayPropertiesBuilder_.dispose(); + textArrayPropertiesBuilder_ = null; + textArrayProperties_ = other.textArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000020); + textArrayPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getTextArrayPropertiesFieldBuilder() : null; + } else { + textArrayPropertiesBuilder_.addAllMessages(other.textArrayProperties_); + } + } + } + if (booleanArrayPropertiesBuilder_ == null) { + if (!other.booleanArrayProperties_.isEmpty()) { + if (booleanArrayProperties_.isEmpty()) { + booleanArrayProperties_ = other.booleanArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.addAll(other.booleanArrayProperties_); + } + onChanged(); + } + } else { + if (!other.booleanArrayProperties_.isEmpty()) { + if (booleanArrayPropertiesBuilder_.isEmpty()) { + booleanArrayPropertiesBuilder_.dispose(); + booleanArrayPropertiesBuilder_ = null; + booleanArrayProperties_ = other.booleanArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000040); + booleanArrayPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getBooleanArrayPropertiesFieldBuilder() : null; + } else { + booleanArrayPropertiesBuilder_.addAllMessages(other.booleanArrayProperties_); + } + } + } + if (objectPropertiesBuilder_ == null) { + if (!other.objectProperties_.isEmpty()) { + if (objectProperties_.isEmpty()) { + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureObjectPropertiesIsMutable(); + objectProperties_.addAll(other.objectProperties_); + } + onChanged(); + } + } else { + if (!other.objectProperties_.isEmpty()) { + if (objectPropertiesBuilder_.isEmpty()) { + objectPropertiesBuilder_.dispose(); + objectPropertiesBuilder_ = null; + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000080); + objectPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getObjectPropertiesFieldBuilder() : null; + } else { + objectPropertiesBuilder_.addAllMessages(other.objectProperties_); + } + } + } + if (objectArrayPropertiesBuilder_ == null) { + if (!other.objectArrayProperties_.isEmpty()) { + if (objectArrayProperties_.isEmpty()) { + objectArrayProperties_ = other.objectArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000100); + } else { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.addAll(other.objectArrayProperties_); + } + onChanged(); + } + } else { + if (!other.objectArrayProperties_.isEmpty()) { + if (objectArrayPropertiesBuilder_.isEmpty()) { + objectArrayPropertiesBuilder_.dispose(); + objectArrayPropertiesBuilder_ = null; + objectArrayProperties_ = other.objectArrayProperties_; + bitField0_ = (bitField0_ & ~0x00000100); + objectArrayPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getObjectArrayPropertiesFieldBuilder() : null; + } else { + objectArrayPropertiesBuilder_.addAllMessages(other.objectArrayProperties_); + } + } + } + if (!other.emptyListProps_.isEmpty()) { + if (emptyListProps_.isEmpty()) { + emptyListProps_ = other.emptyListProps_; + bitField0_ |= 0x00000200; + } else { + ensureEmptyListPropsIsMutable(); + emptyListProps_.addAll(other.emptyListProps_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + input.readMessage( + getNonRefPropertiesFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.parser(), + extensionRegistry); + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.add(m); + } else { + singleTargetRefPropsBuilder_.addMessage(m); + } + break; + } // case 18 + case 26: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.parser(), + extensionRegistry); + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.add(m); + } else { + multiTargetRefPropsBuilder_.addMessage(m); + } + break; + } // case 26 + case 34: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.parser(), + extensionRegistry); + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.add(m); + } else { + numberArrayPropertiesBuilder_.addMessage(m); + } + break; + } // case 34 + case 42: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.parser(), + extensionRegistry); + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.add(m); + } else { + intArrayPropertiesBuilder_.addMessage(m); + } + break; + } // case 42 + case 50: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.parser(), + extensionRegistry); + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.add(m); + } else { + textArrayPropertiesBuilder_.addMessage(m); + } + break; + } // case 50 + case 58: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.parser(), + extensionRegistry); + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.add(m); + } else { + booleanArrayPropertiesBuilder_.addMessage(m); + } + break; + } // case 58 + case 66: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.parser(), + extensionRegistry); + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(m); + } else { + objectPropertiesBuilder_.addMessage(m); + } + break; + } // case 66 + case 74: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.parser(), + extensionRegistry); + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.add(m); + } else { + objectArrayPropertiesBuilder_.addMessage(m); + } + break; + } // case 74 + case 82: { + java.lang.String s = input.readStringRequireUtf8(); + ensureEmptyListPropsIsMutable(); + emptyListProps_.add(s); + break; + } // case 82 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.Struct nonRefProperties_; + private com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder> nonRefPropertiesBuilder_; + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return Whether the nonRefProperties field is set. + */ + public boolean hasNonRefProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + * @return The nonRefProperties. + */ + public com.google.protobuf.Struct getNonRefProperties() { + if (nonRefPropertiesBuilder_ == null) { + return nonRefProperties_ == null ? com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; + } else { + return nonRefPropertiesBuilder_.getMessage(); + } + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public Builder setNonRefProperties(com.google.protobuf.Struct value) { + if (nonRefPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nonRefProperties_ = value; + } else { + nonRefPropertiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public Builder setNonRefProperties( + com.google.protobuf.Struct.Builder builderForValue) { + if (nonRefPropertiesBuilder_ == null) { + nonRefProperties_ = builderForValue.build(); + } else { + nonRefPropertiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public Builder mergeNonRefProperties(com.google.protobuf.Struct value) { + if (nonRefPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + nonRefProperties_ != null && + nonRefProperties_ != com.google.protobuf.Struct.getDefaultInstance()) { + getNonRefPropertiesBuilder().mergeFrom(value); + } else { + nonRefProperties_ = value; + } + } else { + nonRefPropertiesBuilder_.mergeFrom(value); + } + if (nonRefProperties_ != null) { + bitField0_ |= 0x00000001; + onChanged(); + } + return this; + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public Builder clearNonRefProperties() { + bitField0_ = (bitField0_ & ~0x00000001); + nonRefProperties_ = null; + if (nonRefPropertiesBuilder_ != null) { + nonRefPropertiesBuilder_.dispose(); + nonRefPropertiesBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public com.google.protobuf.Struct.Builder getNonRefPropertiesBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getNonRefPropertiesFieldBuilder().getBuilder(); + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + public com.google.protobuf.StructOrBuilder getNonRefPropertiesOrBuilder() { + if (nonRefPropertiesBuilder_ != null) { + return nonRefPropertiesBuilder_.getMessageOrBuilder(); + } else { + return nonRefProperties_ == null ? + com.google.protobuf.Struct.getDefaultInstance() : nonRefProperties_; + } + } + /** + * .google.protobuf.Struct non_ref_properties = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder> + getNonRefPropertiesFieldBuilder() { + if (nonRefPropertiesBuilder_ == null) { + nonRefPropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.google.protobuf.Struct, com.google.protobuf.Struct.Builder, com.google.protobuf.StructOrBuilder>( + getNonRefProperties(), + getParentForChildren(), + isClean()); + nonRefProperties_ = null; + } + return nonRefPropertiesBuilder_; + } + + private java.util.List singleTargetRefProps_ = + java.util.Collections.emptyList(); + private void ensureSingleTargetRefPropsIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + singleTargetRefProps_ = new java.util.ArrayList(singleTargetRefProps_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder> singleTargetRefPropsBuilder_; + + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public java.util.List getSingleTargetRefPropsList() { + if (singleTargetRefPropsBuilder_ == null) { + return java.util.Collections.unmodifiableList(singleTargetRefProps_); + } else { + return singleTargetRefPropsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public int getSingleTargetRefPropsCount() { + if (singleTargetRefPropsBuilder_ == null) { + return singleTargetRefProps_.size(); + } else { + return singleTargetRefPropsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getSingleTargetRefProps(int index) { + if (singleTargetRefPropsBuilder_ == null) { + return singleTargetRefProps_.get(index); + } else { + return singleTargetRefPropsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder setSingleTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { + if (singleTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.set(index, value); + onChanged(); + } else { + singleTargetRefPropsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder setSingleTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.set(index, builderForValue.build()); + onChanged(); + } else { + singleTargetRefPropsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder addSingleTargetRefProps(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { + if (singleTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.add(value); + onChanged(); + } else { + singleTargetRefPropsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder addSingleTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps value) { + if (singleTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.add(index, value); + onChanged(); + } else { + singleTargetRefPropsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder addSingleTargetRefProps( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.add(builderForValue.build()); + onChanged(); + } else { + singleTargetRefPropsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder addSingleTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder builderForValue) { + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.add(index, builderForValue.build()); + onChanged(); + } else { + singleTargetRefPropsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder addAllSingleTargetRefProps( + java.lang.Iterable values) { + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, singleTargetRefProps_); + onChanged(); + } else { + singleTargetRefPropsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder clearSingleTargetRefProps() { + if (singleTargetRefPropsBuilder_ == null) { + singleTargetRefProps_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + singleTargetRefPropsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public Builder removeSingleTargetRefProps(int index) { + if (singleTargetRefPropsBuilder_ == null) { + ensureSingleTargetRefPropsIsMutable(); + singleTargetRefProps_.remove(index); + onChanged(); + } else { + singleTargetRefPropsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder getSingleTargetRefPropsBuilder( + int index) { + return getSingleTargetRefPropsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder getSingleTargetRefPropsOrBuilder( + int index) { + if (singleTargetRefPropsBuilder_ == null) { + return singleTargetRefProps_.get(index); } else { + return singleTargetRefPropsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public java.util.List + getSingleTargetRefPropsOrBuilderList() { + if (singleTargetRefPropsBuilder_ != null) { + return singleTargetRefPropsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(singleTargetRefProps_); + } + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder addSingleTargetRefPropsBuilder() { + return getSingleTargetRefPropsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder addSingleTargetRefPropsBuilder( + int index) { + return getSingleTargetRefPropsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObject.SingleTargetRefProps single_target_ref_props = 2; + */ + public java.util.List + getSingleTargetRefPropsBuilderList() { + return getSingleTargetRefPropsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder> + getSingleTargetRefPropsFieldBuilder() { + if (singleTargetRefPropsBuilder_ == null) { + singleTargetRefPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder>( + singleTargetRefProps_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + singleTargetRefProps_ = null; + } + return singleTargetRefPropsBuilder_; + } + + private java.util.List multiTargetRefProps_ = + java.util.Collections.emptyList(); + private void ensureMultiTargetRefPropsIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + multiTargetRefProps_ = new java.util.ArrayList(multiTargetRefProps_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder> multiTargetRefPropsBuilder_; + + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public java.util.List getMultiTargetRefPropsList() { + if (multiTargetRefPropsBuilder_ == null) { + return java.util.Collections.unmodifiableList(multiTargetRefProps_); + } else { + return multiTargetRefPropsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public int getMultiTargetRefPropsCount() { + if (multiTargetRefPropsBuilder_ == null) { + return multiTargetRefProps_.size(); + } else { + return multiTargetRefPropsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getMultiTargetRefProps(int index) { + if (multiTargetRefPropsBuilder_ == null) { + return multiTargetRefProps_.get(index); + } else { + return multiTargetRefPropsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder setMultiTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { + if (multiTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.set(index, value); + onChanged(); + } else { + multiTargetRefPropsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder setMultiTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.set(index, builderForValue.build()); + onChanged(); + } else { + multiTargetRefPropsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder addMultiTargetRefProps(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { + if (multiTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.add(value); + onChanged(); + } else { + multiTargetRefPropsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder addMultiTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps value) { + if (multiTargetRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.add(index, value); + onChanged(); + } else { + multiTargetRefPropsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder addMultiTargetRefProps( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.add(builderForValue.build()); + onChanged(); + } else { + multiTargetRefPropsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder addMultiTargetRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder builderForValue) { + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.add(index, builderForValue.build()); + onChanged(); + } else { + multiTargetRefPropsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder addAllMultiTargetRefProps( + java.lang.Iterable values) { + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, multiTargetRefProps_); + onChanged(); + } else { + multiTargetRefPropsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder clearMultiTargetRefProps() { + if (multiTargetRefPropsBuilder_ == null) { + multiTargetRefProps_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + multiTargetRefPropsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public Builder removeMultiTargetRefProps(int index) { + if (multiTargetRefPropsBuilder_ == null) { + ensureMultiTargetRefPropsIsMutable(); + multiTargetRefProps_.remove(index); + onChanged(); + } else { + multiTargetRefPropsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder getMultiTargetRefPropsBuilder( + int index) { + return getMultiTargetRefPropsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder getMultiTargetRefPropsOrBuilder( + int index) { + if (multiTargetRefPropsBuilder_ == null) { + return multiTargetRefProps_.get(index); } else { + return multiTargetRefPropsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public java.util.List + getMultiTargetRefPropsOrBuilderList() { + if (multiTargetRefPropsBuilder_ != null) { + return multiTargetRefPropsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(multiTargetRefProps_); + } + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder addMultiTargetRefPropsBuilder() { + return getMultiTargetRefPropsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder addMultiTargetRefPropsBuilder( + int index) { + return getMultiTargetRefPropsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObject.MultiTargetRefProps multi_target_ref_props = 3; + */ + public java.util.List + getMultiTargetRefPropsBuilderList() { + return getMultiTargetRefPropsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder> + getMultiTargetRefPropsFieldBuilder() { + if (multiTargetRefPropsBuilder_ == null) { + multiTargetRefPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder>( + multiTargetRefProps_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + multiTargetRefProps_ = null; + } + return multiTargetRefPropsBuilder_; + } + + private java.util.List numberArrayProperties_ = + java.util.Collections.emptyList(); + private void ensureNumberArrayPropertiesIsMutable() { + if (!((bitField0_ & 0x00000008) != 0)) { + numberArrayProperties_ = new java.util.ArrayList(numberArrayProperties_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> numberArrayPropertiesBuilder_; + + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public java.util.List getNumberArrayPropertiesList() { + if (numberArrayPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(numberArrayProperties_); + } else { + return numberArrayPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public int getNumberArrayPropertiesCount() { + if (numberArrayPropertiesBuilder_ == null) { + return numberArrayProperties_.size(); + } else { + return numberArrayPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties getNumberArrayProperties(int index) { + if (numberArrayPropertiesBuilder_ == null) { + return numberArrayProperties_.get(index); + } else { + return numberArrayPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder setNumberArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) { + if (numberArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.set(index, value); + onChanged(); + } else { + numberArrayPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder setNumberArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + numberArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder addNumberArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) { + if (numberArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.add(value); + onChanged(); + } else { + numberArrayPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder addNumberArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties value) { + if (numberArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.add(index, value); + onChanged(); + } else { + numberArrayPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder addNumberArrayProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.add(builderForValue.build()); + onChanged(); + } else { + numberArrayPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder addNumberArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder builderForValue) { + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + numberArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder addAllNumberArrayProperties( + java.lang.Iterable values) { + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, numberArrayProperties_); + onChanged(); + } else { + numberArrayPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder clearNumberArrayProperties() { + if (numberArrayPropertiesBuilder_ == null) { + numberArrayProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + numberArrayPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public Builder removeNumberArrayProperties(int index) { + if (numberArrayPropertiesBuilder_ == null) { + ensureNumberArrayPropertiesIsMutable(); + numberArrayProperties_.remove(index); + onChanged(); + } else { + numberArrayPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder getNumberArrayPropertiesBuilder( + int index) { + return getNumberArrayPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder getNumberArrayPropertiesOrBuilder( + int index) { + if (numberArrayPropertiesBuilder_ == null) { + return numberArrayProperties_.get(index); } else { + return numberArrayPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public java.util.List + getNumberArrayPropertiesOrBuilderList() { + if (numberArrayPropertiesBuilder_ != null) { + return numberArrayPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(numberArrayProperties_); + } + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder() { + return getNumberArrayPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder addNumberArrayPropertiesBuilder( + int index) { + return getNumberArrayPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.NumberArrayProperties number_array_properties = 4; + */ + public java.util.List + getNumberArrayPropertiesBuilderList() { + return getNumberArrayPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder> + getNumberArrayPropertiesFieldBuilder() { + if (numberArrayPropertiesBuilder_ == null) { + numberArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.NumberArrayPropertiesOrBuilder>( + numberArrayProperties_, + ((bitField0_ & 0x00000008) != 0), + getParentForChildren(), + isClean()); + numberArrayProperties_ = null; + } + return numberArrayPropertiesBuilder_; + } + + private java.util.List intArrayProperties_ = + java.util.Collections.emptyList(); + private void ensureIntArrayPropertiesIsMutable() { + if (!((bitField0_ & 0x00000010) != 0)) { + intArrayProperties_ = new java.util.ArrayList(intArrayProperties_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder> intArrayPropertiesBuilder_; + + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public java.util.List getIntArrayPropertiesList() { + if (intArrayPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(intArrayProperties_); + } else { + return intArrayPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public int getIntArrayPropertiesCount() { + if (intArrayPropertiesBuilder_ == null) { + return intArrayProperties_.size(); + } else { + return intArrayPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties getIntArrayProperties(int index) { + if (intArrayPropertiesBuilder_ == null) { + return intArrayProperties_.get(index); + } else { + return intArrayPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder setIntArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) { + if (intArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.set(index, value); + onChanged(); + } else { + intArrayPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder setIntArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + intArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder addIntArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) { + if (intArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.add(value); + onChanged(); + } else { + intArrayPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder addIntArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties value) { + if (intArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.add(index, value); + onChanged(); + } else { + intArrayPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder addIntArrayProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.add(builderForValue.build()); + onChanged(); + } else { + intArrayPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder addIntArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder builderForValue) { + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + intArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder addAllIntArrayProperties( + java.lang.Iterable values) { + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, intArrayProperties_); + onChanged(); + } else { + intArrayPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder clearIntArrayProperties() { + if (intArrayPropertiesBuilder_ == null) { + intArrayProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + intArrayPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public Builder removeIntArrayProperties(int index) { + if (intArrayPropertiesBuilder_ == null) { + ensureIntArrayPropertiesIsMutable(); + intArrayProperties_.remove(index); + onChanged(); + } else { + intArrayPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder getIntArrayPropertiesBuilder( + int index) { + return getIntArrayPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder getIntArrayPropertiesOrBuilder( + int index) { + if (intArrayPropertiesBuilder_ == null) { + return intArrayProperties_.get(index); } else { + return intArrayPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public java.util.List + getIntArrayPropertiesOrBuilderList() { + if (intArrayPropertiesBuilder_ != null) { + return intArrayPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(intArrayProperties_); + } + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder() { + return getIntArrayPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder addIntArrayPropertiesBuilder( + int index) { + return getIntArrayPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.IntArrayProperties int_array_properties = 5; + */ + public java.util.List + getIntArrayPropertiesBuilderList() { + return getIntArrayPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder> + getIntArrayPropertiesFieldBuilder() { + if (intArrayPropertiesBuilder_ == null) { + intArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.IntArrayPropertiesOrBuilder>( + intArrayProperties_, + ((bitField0_ & 0x00000010) != 0), + getParentForChildren(), + isClean()); + intArrayProperties_ = null; + } + return intArrayPropertiesBuilder_; + } + + private java.util.List textArrayProperties_ = + java.util.Collections.emptyList(); + private void ensureTextArrayPropertiesIsMutable() { + if (!((bitField0_ & 0x00000020) != 0)) { + textArrayProperties_ = new java.util.ArrayList(textArrayProperties_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder> textArrayPropertiesBuilder_; + + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public java.util.List getTextArrayPropertiesList() { + if (textArrayPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(textArrayProperties_); + } else { + return textArrayPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public int getTextArrayPropertiesCount() { + if (textArrayPropertiesBuilder_ == null) { + return textArrayProperties_.size(); + } else { + return textArrayPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties getTextArrayProperties(int index) { + if (textArrayPropertiesBuilder_ == null) { + return textArrayProperties_.get(index); + } else { + return textArrayPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder setTextArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) { + if (textArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.set(index, value); + onChanged(); + } else { + textArrayPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder setTextArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + textArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder addTextArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) { + if (textArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.add(value); + onChanged(); + } else { + textArrayPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder addTextArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties value) { + if (textArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.add(index, value); + onChanged(); + } else { + textArrayPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder addTextArrayProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.add(builderForValue.build()); + onChanged(); + } else { + textArrayPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder addTextArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder builderForValue) { + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + textArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder addAllTextArrayProperties( + java.lang.Iterable values) { + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, textArrayProperties_); + onChanged(); + } else { + textArrayPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder clearTextArrayProperties() { + if (textArrayPropertiesBuilder_ == null) { + textArrayProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + textArrayPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public Builder removeTextArrayProperties(int index) { + if (textArrayPropertiesBuilder_ == null) { + ensureTextArrayPropertiesIsMutable(); + textArrayProperties_.remove(index); + onChanged(); + } else { + textArrayPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder getTextArrayPropertiesBuilder( + int index) { + return getTextArrayPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder getTextArrayPropertiesOrBuilder( + int index) { + if (textArrayPropertiesBuilder_ == null) { + return textArrayProperties_.get(index); } else { + return textArrayPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public java.util.List + getTextArrayPropertiesOrBuilderList() { + if (textArrayPropertiesBuilder_ != null) { + return textArrayPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(textArrayProperties_); + } + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder() { + return getTextArrayPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder addTextArrayPropertiesBuilder( + int index) { + return getTextArrayPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.TextArrayProperties text_array_properties = 6; + */ + public java.util.List + getTextArrayPropertiesBuilderList() { + return getTextArrayPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder> + getTextArrayPropertiesFieldBuilder() { + if (textArrayPropertiesBuilder_ == null) { + textArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayPropertiesOrBuilder>( + textArrayProperties_, + ((bitField0_ & 0x00000020) != 0), + getParentForChildren(), + isClean()); + textArrayProperties_ = null; + } + return textArrayPropertiesBuilder_; + } + + private java.util.List booleanArrayProperties_ = + java.util.Collections.emptyList(); + private void ensureBooleanArrayPropertiesIsMutable() { + if (!((bitField0_ & 0x00000040) != 0)) { + booleanArrayProperties_ = new java.util.ArrayList(booleanArrayProperties_); + bitField0_ |= 0x00000040; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> booleanArrayPropertiesBuilder_; + + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public java.util.List getBooleanArrayPropertiesList() { + if (booleanArrayPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(booleanArrayProperties_); + } else { + return booleanArrayPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public int getBooleanArrayPropertiesCount() { + if (booleanArrayPropertiesBuilder_ == null) { + return booleanArrayProperties_.size(); + } else { + return booleanArrayPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties getBooleanArrayProperties(int index) { + if (booleanArrayPropertiesBuilder_ == null) { + return booleanArrayProperties_.get(index); + } else { + return booleanArrayPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder setBooleanArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) { + if (booleanArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.set(index, value); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder setBooleanArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder addBooleanArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) { + if (booleanArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.add(value); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder addBooleanArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties value) { + if (booleanArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.add(index, value); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder addBooleanArrayProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.add(builderForValue.build()); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder addBooleanArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder builderForValue) { + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder addAllBooleanArrayProperties( + java.lang.Iterable values) { + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, booleanArrayProperties_); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder clearBooleanArrayProperties() { + if (booleanArrayPropertiesBuilder_ == null) { + booleanArrayProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public Builder removeBooleanArrayProperties(int index) { + if (booleanArrayPropertiesBuilder_ == null) { + ensureBooleanArrayPropertiesIsMutable(); + booleanArrayProperties_.remove(index); + onChanged(); + } else { + booleanArrayPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder getBooleanArrayPropertiesBuilder( + int index) { + return getBooleanArrayPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder getBooleanArrayPropertiesOrBuilder( + int index) { + if (booleanArrayPropertiesBuilder_ == null) { + return booleanArrayProperties_.get(index); } else { + return booleanArrayPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public java.util.List + getBooleanArrayPropertiesOrBuilderList() { + if (booleanArrayPropertiesBuilder_ != null) { + return booleanArrayPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(booleanArrayProperties_); + } + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder() { + return getBooleanArrayPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder addBooleanArrayPropertiesBuilder( + int index) { + return getBooleanArrayPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BooleanArrayProperties boolean_array_properties = 7; + */ + public java.util.List + getBooleanArrayPropertiesBuilderList() { + return getBooleanArrayPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder> + getBooleanArrayPropertiesFieldBuilder() { + if (booleanArrayPropertiesBuilder_ == null) { + booleanArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.BooleanArrayPropertiesOrBuilder>( + booleanArrayProperties_, + ((bitField0_ & 0x00000040) != 0), + getParentForChildren(), + isClean()); + booleanArrayProperties_ = null; + } + return booleanArrayPropertiesBuilder_; + } + + private java.util.List objectProperties_ = + java.util.Collections.emptyList(); + private void ensureObjectPropertiesIsMutable() { + if (!((bitField0_ & 0x00000080) != 0)) { + objectProperties_ = new java.util.ArrayList(objectProperties_); + bitField0_ |= 0x00000080; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder> objectPropertiesBuilder_; + + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public java.util.List getObjectPropertiesList() { + if (objectPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(objectProperties_); + } else { + return objectPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public int getObjectPropertiesCount() { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.size(); + } else { + return objectPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties getObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); + } else { + return objectPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder addObjectProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder addObjectProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder addAllObjectProperties( + java.lang.Iterable values) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, objectProperties_); + onChanged(); + } else { + objectPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder clearObjectProperties() { + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + onChanged(); + } else { + objectPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public Builder removeObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.remove(index); + onChanged(); + } else { + objectPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder getObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder getObjectPropertiesOrBuilder( + int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); } else { + return objectPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public java.util.List + getObjectPropertiesOrBuilderList() { + if (objectPropertiesBuilder_ != null) { + return objectPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(objectProperties_); + } + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder() { + return getObjectPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder addObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectProperties object_properties = 8; + */ + public java.util.List + getObjectPropertiesBuilderList() { + return getObjectPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder> + getObjectPropertiesFieldBuilder() { + if (objectPropertiesBuilder_ == null) { + objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectPropertiesOrBuilder>( + objectProperties_, + ((bitField0_ & 0x00000080) != 0), + getParentForChildren(), + isClean()); + objectProperties_ = null; + } + return objectPropertiesBuilder_; + } + + private java.util.List objectArrayProperties_ = + java.util.Collections.emptyList(); + private void ensureObjectArrayPropertiesIsMutable() { + if (!((bitField0_ & 0x00000100) != 0)) { + objectArrayProperties_ = new java.util.ArrayList(objectArrayProperties_); + bitField0_ |= 0x00000100; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> objectArrayPropertiesBuilder_; + + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public java.util.List getObjectArrayPropertiesList() { + if (objectArrayPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(objectArrayProperties_); + } else { + return objectArrayPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public int getObjectArrayPropertiesCount() { + if (objectArrayPropertiesBuilder_ == null) { + return objectArrayProperties_.size(); + } else { + return objectArrayPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties getObjectArrayProperties(int index) { + if (objectArrayPropertiesBuilder_ == null) { + return objectArrayProperties_.get(index); + } else { + return objectArrayPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder setObjectArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) { + if (objectArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.set(index, value); + onChanged(); + } else { + objectArrayPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder setObjectArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + objectArrayPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder addObjectArrayProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) { + if (objectArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.add(value); + onChanged(); + } else { + objectArrayPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder addObjectArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties value) { + if (objectArrayPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.add(index, value); + onChanged(); + } else { + objectArrayPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder addObjectArrayProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.add(builderForValue.build()); + onChanged(); + } else { + objectArrayPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder addObjectArrayProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder builderForValue) { + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + objectArrayPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder addAllObjectArrayProperties( + java.lang.Iterable values) { + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, objectArrayProperties_); + onChanged(); + } else { + objectArrayPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder clearObjectArrayProperties() { + if (objectArrayPropertiesBuilder_ == null) { + objectArrayProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000100); + onChanged(); + } else { + objectArrayPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public Builder removeObjectArrayProperties(int index) { + if (objectArrayPropertiesBuilder_ == null) { + ensureObjectArrayPropertiesIsMutable(); + objectArrayProperties_.remove(index); + onChanged(); + } else { + objectArrayPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder getObjectArrayPropertiesBuilder( + int index) { + return getObjectArrayPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder getObjectArrayPropertiesOrBuilder( + int index) { + if (objectArrayPropertiesBuilder_ == null) { + return objectArrayProperties_.get(index); } else { + return objectArrayPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public java.util.List + getObjectArrayPropertiesOrBuilderList() { + if (objectArrayPropertiesBuilder_ != null) { + return objectArrayPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(objectArrayProperties_); + } + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder() { + return getObjectArrayPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder addObjectArrayPropertiesBuilder( + int index) { + return getObjectArrayPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectArrayProperties object_array_properties = 9; + */ + public java.util.List + getObjectArrayPropertiesBuilderList() { + return getObjectArrayPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder> + getObjectArrayPropertiesFieldBuilder() { + if (objectArrayPropertiesBuilder_ == null) { + objectArrayPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayProperties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ObjectArrayPropertiesOrBuilder>( + objectArrayProperties_, + ((bitField0_ & 0x00000100) != 0), + getParentForChildren(), + isClean()); + objectArrayProperties_ = null; + } + return objectArrayPropertiesBuilder_; + } + + private com.google.protobuf.LazyStringArrayList emptyListProps_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureEmptyListPropsIsMutable() { + if (!emptyListProps_.isModifiable()) { + emptyListProps_ = new com.google.protobuf.LazyStringArrayList(emptyListProps_); + } + bitField0_ |= 0x00000200; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @return A list containing the emptyListProps. + */ + public com.google.protobuf.ProtocolStringList + getEmptyListPropsList() { + emptyListProps_.makeImmutable(); + return emptyListProps_; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @return The count of emptyListProps. + */ + public int getEmptyListPropsCount() { + return emptyListProps_.size(); + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the element to return. + * @return The emptyListProps at the given index. + */ + public java.lang.String getEmptyListProps(int index) { + return emptyListProps_.get(index); + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param index The index of the value to return. + * @return The bytes of the emptyListProps at the given index. + */ + public com.google.protobuf.ByteString + getEmptyListPropsBytes(int index) { + return emptyListProps_.getByteString(index); + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param index The index to set the value at. + * @param value The emptyListProps to set. + * @return This builder for chaining. + */ + public Builder setEmptyListProps( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureEmptyListPropsIsMutable(); + emptyListProps_.set(index, value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param value The emptyListProps to add. + * @return This builder for chaining. + */ + public Builder addEmptyListProps( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureEmptyListPropsIsMutable(); + emptyListProps_.add(value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param values The emptyListProps to add. + * @return This builder for chaining. + */ + public Builder addAllEmptyListProps( + java.lang.Iterable values) { + ensureEmptyListPropsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, emptyListProps_); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @return This builder for chaining. + */ + public Builder clearEmptyListProps() { + emptyListProps_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200);; + onChanged(); + return this; + } + /** + *
+         * empty lists do not have a type in many languages and clients do not know which datatype the property has.
+         * Weaviate can get the datatype from its schema
+         * 
+ * + * repeated string empty_list_props = 10; + * @param value The bytes of the emptyListProps to add. + * @return This builder for chaining. + */ + public Builder addEmptyListPropsBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureEmptyListPropsIsMutable(); + emptyListProps_.add(value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.Properties) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.Properties) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Properties parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SingleTargetRefPropsOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.SingleTargetRefProps) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + java.util.List + getUuidsList(); + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + int getUuidsCount(); + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + java.lang.String getUuids(int index); + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + com.google.protobuf.ByteString + getUuidsBytes(int index); + + /** + * string prop_name = 2; + * @return The propName. + */ + java.lang.String getPropName(); + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + com.google.protobuf.ByteString + getPropNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.SingleTargetRefProps} + */ + public static final class SingleTargetRefProps extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.SingleTargetRefProps) + SingleTargetRefPropsOrBuilder { + private static final long serialVersionUID = 0L; + // Use SingleTargetRefProps.newBuilder() to construct. + private SingleTargetRefProps(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SingleTargetRefProps() { + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + propName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SingleTargetRefProps(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder.class); + } + + public static final int UUIDS_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + public com.google.protobuf.ProtocolStringList + getUuidsList() { + return uuids_; + } + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + public int getUuidsCount() { + return uuids_.size(); + } + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + public java.lang.String getUuids(int index) { + return uuids_.get(index); + } + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + public com.google.protobuf.ByteString + getUuidsBytes(int index) { + return uuids_.getByteString(index); + } + + public static final int PROP_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + @java.lang.Override + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < uuids_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuids_.getRaw(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < uuids_.size(); i++) { + dataSize += computeStringSizeNoTag(uuids_.getRaw(i)); + } + size += dataSize; + size += 1 * getUuidsList().size(); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps) obj; + + if (!getUuidsList() + .equals(other.getUuidsList())) return false; + if (!getPropName() + .equals(other.getPropName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getUuidsCount() > 0) { + hash = (37 * hash) + UUIDS_FIELD_NUMBER; + hash = (53 * hash) + getUuidsList().hashCode(); + } + hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; + hash = (53 * hash) + getPropName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.SingleTargetRefProps} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.SingleTargetRefProps) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefPropsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + propName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + uuids_.makeImmutable(); + result.uuids_ = uuids_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.propName_ = propName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps.getDefaultInstance()) return this; + if (!other.uuids_.isEmpty()) { + if (uuids_.isEmpty()) { + uuids_ = other.uuids_; + bitField0_ |= 0x00000001; + } else { + ensureUuidsIsMutable(); + uuids_.addAll(other.uuids_); + } + onChanged(); + } + if (!other.getPropName().isEmpty()) { + propName_ = other.propName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureUuidsIsMutable(); + uuids_.add(s); + break; + } // case 10 + case 18: { + propName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureUuidsIsMutable() { + if (!uuids_.isModifiable()) { + uuids_ = new com.google.protobuf.LazyStringArrayList(uuids_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + public com.google.protobuf.ProtocolStringList + getUuidsList() { + uuids_.makeImmutable(); + return uuids_; + } + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + public int getUuidsCount() { + return uuids_.size(); + } + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + public java.lang.String getUuids(int index) { + return uuids_.get(index); + } + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + public com.google.protobuf.ByteString + getUuidsBytes(int index) { + return uuids_.getByteString(index); + } + /** + * repeated string uuids = 1; + * @param index The index to set the value at. + * @param value The uuids to set. + * @return This builder for chaining. + */ + public Builder setUuids( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureUuidsIsMutable(); + uuids_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param value The uuids to add. + * @return This builder for chaining. + */ + public Builder addUuids( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureUuidsIsMutable(); + uuids_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param values The uuids to add. + * @return This builder for chaining. + */ + public Builder addAllUuids( + java.lang.Iterable values) { + ensureUuidsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, uuids_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @return This builder for chaining. + */ + public Builder clearUuids() { + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param value The bytes of the uuids to add. + * @return This builder for chaining. + */ + public Builder addUuidsBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureUuidsIsMutable(); + uuids_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string prop_name = 2; + * @param value The propName to set. + * @return This builder for chaining. + */ + public Builder setPropName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @return This builder for chaining. + */ + public Builder clearPropName() { + propName_ = getDefaultInstance().getPropName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @param value The bytes for propName to set. + * @return This builder for chaining. + */ + public Builder setPropNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.SingleTargetRefProps) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.SingleTargetRefProps) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SingleTargetRefProps parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.SingleTargetRefProps getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface MultiTargetRefPropsOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObject.MultiTargetRefProps) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + java.util.List + getUuidsList(); + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + int getUuidsCount(); + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + java.lang.String getUuids(int index); + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + com.google.protobuf.ByteString + getUuidsBytes(int index); + + /** + * string prop_name = 2; + * @return The propName. + */ + java.lang.String getPropName(); + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + com.google.protobuf.ByteString + getPropNameBytes(); + + /** + * string target_collection = 3; + * @return The targetCollection. + */ + java.lang.String getTargetCollection(); + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + com.google.protobuf.ByteString + getTargetCollectionBytes(); + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.MultiTargetRefProps} + */ + public static final class MultiTargetRefProps extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObject.MultiTargetRefProps) + MultiTargetRefPropsOrBuilder { + private static final long serialVersionUID = 0L; + // Use MultiTargetRefProps.newBuilder() to construct. + private MultiTargetRefProps(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private MultiTargetRefProps() { + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + propName_ = ""; + targetCollection_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new MultiTargetRefProps(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder.class); + } + + public static final int UUIDS_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + public com.google.protobuf.ProtocolStringList + getUuidsList() { + return uuids_; + } + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + public int getUuidsCount() { + return uuids_.size(); + } + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + public java.lang.String getUuids(int index) { + return uuids_.get(index); + } + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + public com.google.protobuf.ByteString + getUuidsBytes(int index) { + return uuids_.getByteString(index); + } + + public static final int PROP_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + @java.lang.Override + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TARGET_COLLECTION_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 3; + * @return The targetCollection. + */ + @java.lang.Override + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } + } + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < uuids_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuids_.getRaw(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, targetCollection_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < uuids_.size(); i++) { + dataSize += computeStringSizeNoTag(uuids_.getRaw(i)); + } + size += dataSize; + size += 1 * getUuidsList().size(); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, targetCollection_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps) obj; + + if (!getUuidsList() + .equals(other.getUuidsList())) return false; + if (!getPropName() + .equals(other.getPropName())) return false; + if (!getTargetCollection() + .equals(other.getTargetCollection())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getUuidsCount() > 0) { + hash = (37 * hash) + UUIDS_FIELD_NUMBER; + hash = (53 * hash) + getUuidsList().hashCode(); + } + hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; + hash = (53 * hash) + getPropName().hashCode(); + hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getTargetCollection().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObject.MultiTargetRefProps} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject.MultiTargetRefProps) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefPropsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + propName_ = ""; + targetCollection_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + uuids_.makeImmutable(); + result.uuids_ = uuids_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.propName_ = propName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.targetCollection_ = targetCollection_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps.getDefaultInstance()) return this; + if (!other.uuids_.isEmpty()) { + if (uuids_.isEmpty()) { + uuids_ = other.uuids_; + bitField0_ |= 0x00000001; + } else { + ensureUuidsIsMutable(); + uuids_.addAll(other.uuids_); + } + onChanged(); + } + if (!other.getPropName().isEmpty()) { + propName_ = other.propName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getTargetCollection().isEmpty()) { + targetCollection_ = other.targetCollection_; + bitField0_ |= 0x00000004; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureUuidsIsMutable(); + uuids_.add(s); + break; + } // case 10 + case 18: { + propName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + targetCollection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureUuidsIsMutable() { + if (!uuids_.isModifiable()) { + uuids_ = new com.google.protobuf.LazyStringArrayList(uuids_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string uuids = 1; + * @return A list containing the uuids. + */ + public com.google.protobuf.ProtocolStringList + getUuidsList() { + uuids_.makeImmutable(); + return uuids_; + } + /** + * repeated string uuids = 1; + * @return The count of uuids. + */ + public int getUuidsCount() { + return uuids_.size(); + } + /** + * repeated string uuids = 1; + * @param index The index of the element to return. + * @return The uuids at the given index. + */ + public java.lang.String getUuids(int index) { + return uuids_.get(index); + } + /** + * repeated string uuids = 1; + * @param index The index of the value to return. + * @return The bytes of the uuids at the given index. + */ + public com.google.protobuf.ByteString + getUuidsBytes(int index) { + return uuids_.getByteString(index); + } + /** + * repeated string uuids = 1; + * @param index The index to set the value at. + * @param value The uuids to set. + * @return This builder for chaining. + */ + public Builder setUuids( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureUuidsIsMutable(); + uuids_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param value The uuids to add. + * @return This builder for chaining. + */ + public Builder addUuids( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureUuidsIsMutable(); + uuids_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param values The uuids to add. + * @return This builder for chaining. + */ + public Builder addAllUuids( + java.lang.Iterable values) { + ensureUuidsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, uuids_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @return This builder for chaining. + */ + public Builder clearUuids() { + uuids_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string uuids = 1; + * @param value The bytes of the uuids to add. + * @return This builder for chaining. + */ + public Builder addUuidsBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureUuidsIsMutable(); + uuids_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string prop_name = 2; + * @param value The propName to set. + * @return This builder for chaining. + */ + public Builder setPropName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @return This builder for chaining. + */ + public Builder clearPropName() { + propName_ = getDefaultInstance().getPropName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @param value The bytes for propName to set. + * @return This builder for chaining. + */ + public Builder setPropNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 3; + * @return The targetCollection. + */ + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string target_collection = 3; + * @param value The targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + targetCollection_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string target_collection = 3; + * @return This builder for chaining. + */ + public Builder clearTargetCollection() { + targetCollection_ = getDefaultInstance().getTargetCollection(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string target_collection = 3; + * @param value The bytes for targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + targetCollection_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject.MultiTargetRefProps) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject.MultiTargetRefProps) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public MultiTargetRefProps parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.MultiTargetRefProps getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int UUID_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object uuid_ = ""; + /** + * string uuid = 1; + * @return The uuid. + */ + @java.lang.Override + public java.lang.String getUuid() { + java.lang.Object ref = uuid_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uuid_ = s; + return s; + } + } + /** + * string uuid = 1; + * @return The bytes for uuid. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getUuidBytes() { + java.lang.Object ref = uuid_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VECTOR_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private com.google.protobuf.Internal.FloatList vector_ = + emptyFloatList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return A list containing the vector. + */ + @java.lang.Override + @java.lang.Deprecated public java.util.List + getVectorList() { + return vector_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return The count of vector. + */ + @java.lang.Deprecated public int getVectorCount() { + return vector_.size(); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated public float getVector(int index) { + return vector_.getFloat(index); + } + private int vectorMemoizedSerializedSize = -1; + + public static final int PROPERTIES_FIELD_NUMBER = 3; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties properties_; + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return Whether the properties field is set. + */ + @java.lang.Override + public boolean hasProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return The properties. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getProperties() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; + } + + public static final int COLLECTION_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private volatile java.lang.Object collection_ = ""; + /** + * string collection = 4; + * @return The collection. + */ + @java.lang.Override + public java.lang.String getCollection() { + java.lang.Object ref = collection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + collection_ = s; + return s; + } + } + /** + * string collection = 4; + * @return The bytes for collection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getCollectionBytes() { + java.lang.Object ref = collection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + collection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TENANT_FIELD_NUMBER = 5; + @SuppressWarnings("serial") + private volatile java.lang.Object tenant_ = ""; + /** + * string tenant = 5; + * @return The tenant. + */ + @java.lang.Override + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } + } + /** + * string tenant = 5; + * @return The bytes for tenant. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VECTOR_BYTES_FIELD_NUMBER = 6; + private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes vector_bytes = 6; + * @return The vectorBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getVectorBytes() { + return vectorBytes_; + } + + public static final int VECTORS_FIELD_NUMBER = 23; + @SuppressWarnings("serial") + private java.util.List vectors_; + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public java.util.List getVectorsList() { + return vectors_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public java.util.List + getVectorsOrBuilderList() { + return vectors_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public int getVectorsCount() { + return vectors_.size(); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) { + return vectors_.get(index); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index) { + return vectors_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(uuid_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, uuid_); + } + if (getVectorList().size() > 0) { + output.writeUInt32NoTag(18); + output.writeUInt32NoTag(vectorMemoizedSerializedSize); + } + for (int i = 0; i < vector_.size(); i++) { + output.writeFloatNoTag(vector_.getFloat(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(3, getProperties()); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, collection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 5, tenant_); + } + if (!vectorBytes_.isEmpty()) { + output.writeBytes(6, vectorBytes_); + } + for (int i = 0; i < vectors_.size(); i++) { + output.writeMessage(23, vectors_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(uuid_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, uuid_); + } + { + int dataSize = 0; + dataSize = 4 * getVectorList().size(); + size += dataSize; + if (!getVectorList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + vectorMemoizedSerializedSize = dataSize; + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getProperties()); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, collection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, tenant_); + } + if (!vectorBytes_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(6, vectorBytes_); + } + for (int i = 0; i < vectors_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(23, vectors_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject) obj; + + if (!getUuid() + .equals(other.getUuid())) return false; + if (!getVectorList() + .equals(other.getVectorList())) return false; + if (hasProperties() != other.hasProperties()) return false; + if (hasProperties()) { + if (!getProperties() + .equals(other.getProperties())) return false; + } + if (!getCollection() + .equals(other.getCollection())) return false; + if (!getTenant() + .equals(other.getTenant())) return false; + if (!getVectorBytes() + .equals(other.getVectorBytes())) return false; + if (!getVectorsList() + .equals(other.getVectorsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + UUID_FIELD_NUMBER; + hash = (53 * hash) + getUuid().hashCode(); + if (getVectorCount() > 0) { + hash = (37 * hash) + VECTOR_FIELD_NUMBER; + hash = (53 * hash) + getVectorList().hashCode(); + } + if (hasProperties()) { + hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getProperties().hashCode(); + } + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + hash = (37 * hash) + TENANT_FIELD_NUMBER; + hash = (53 * hash) + getTenant().hashCode(); + hash = (37 * hash) + VECTOR_BYTES_FIELD_NUMBER; + hash = (53 * hash) + getVectorBytes().hashCode(); + if (getVectorsCount() > 0) { + hash = (37 * hash) + VECTORS_FIELD_NUMBER; + hash = (53 * hash) + getVectorsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObject) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPropertiesFieldBuilder(); + getVectorsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + uuid_ = ""; + vector_ = emptyFloatList(); + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + collection_ = ""; + tenant_ = ""; + vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + if (vectorsBuilder_ == null) { + vectors_ = java.util.Collections.emptyList(); + } else { + vectors_ = null; + vectorsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObject_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject result) { + if (vectorsBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0)) { + vectors_ = java.util.Collections.unmodifiableList(vectors_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.vectors_ = vectors_; + } else { + result.vectors_ = vectorsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.uuid_ = uuid_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + vector_.makeImmutable(); + result.vector_ = vector_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000004) != 0)) { + result.properties_ = propertiesBuilder_ == null + ? properties_ + : propertiesBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.collection_ = collection_; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.tenant_ = tenant_; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.vectorBytes_ = vectorBytes_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.getDefaultInstance()) return this; + if (!other.getUuid().isEmpty()) { + uuid_ = other.uuid_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.vector_.isEmpty()) { + if (vector_.isEmpty()) { + vector_ = other.vector_; + vector_.makeImmutable(); + bitField0_ |= 0x00000002; + } else { + ensureVectorIsMutable(); + vector_.addAll(other.vector_); + } + onChanged(); + } + if (other.hasProperties()) { + mergeProperties(other.getProperties()); + } + if (!other.getCollection().isEmpty()) { + collection_ = other.collection_; + bitField0_ |= 0x00000008; + onChanged(); + } + if (!other.getTenant().isEmpty()) { + tenant_ = other.tenant_; + bitField0_ |= 0x00000010; + onChanged(); + } + if (other.getVectorBytes() != com.google.protobuf.ByteString.EMPTY) { + setVectorBytes(other.getVectorBytes()); + } + if (vectorsBuilder_ == null) { + if (!other.vectors_.isEmpty()) { + if (vectors_.isEmpty()) { + vectors_ = other.vectors_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureVectorsIsMutable(); + vectors_.addAll(other.vectors_); + } + onChanged(); + } + } else { + if (!other.vectors_.isEmpty()) { + if (vectorsBuilder_.isEmpty()) { + vectorsBuilder_.dispose(); + vectorsBuilder_ = null; + vectors_ = other.vectors_; + bitField0_ = (bitField0_ & ~0x00000040); + vectorsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getVectorsFieldBuilder() : null; + } else { + vectorsBuilder_.addAllMessages(other.vectors_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + uuid_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 21: { + float v = input.readFloat(); + ensureVectorIsMutable(); + vector_.addFloat(v); + break; + } // case 21 + case 18: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + int alloc = length > 4096 ? 4096 : length; + ensureVectorIsMutable(alloc / 4); + while (input.getBytesUntilLimit() > 0) { + vector_.addFloat(input.readFloat()); + } + input.popLimit(limit); + break; + } // case 18 + case 26: { + input.readMessage( + getPropertiesFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 34: { + collection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000008; + break; + } // case 34 + case 42: { + tenant_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000010; + break; + } // case 42 + case 50: { + vectorBytes_ = input.readBytes(); + bitField0_ |= 0x00000020; + break; + } // case 50 + case 186: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.parser(), + extensionRegistry); + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(m); + } else { + vectorsBuilder_.addMessage(m); + } + break; + } // case 186 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object uuid_ = ""; + /** + * string uuid = 1; + * @return The uuid. + */ + public java.lang.String getUuid() { + java.lang.Object ref = uuid_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + uuid_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string uuid = 1; + * @return The bytes for uuid. + */ + public com.google.protobuf.ByteString + getUuidBytes() { + java.lang.Object ref = uuid_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + uuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string uuid = 1; + * @param value The uuid to set. + * @return This builder for chaining. + */ + public Builder setUuid( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + uuid_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string uuid = 1; + * @return This builder for chaining. + */ + public Builder clearUuid() { + uuid_ = getDefaultInstance().getUuid(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string uuid = 1; + * @param value The bytes for uuid to set. + * @return This builder for chaining. + */ + public Builder setUuidBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + uuid_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private com.google.protobuf.Internal.FloatList vector_ = emptyFloatList(); + private void ensureVectorIsMutable() { + if (!vector_.isModifiable()) { + vector_ = makeMutableCopy(vector_); + } + bitField0_ |= 0x00000002; + } + private void ensureVectorIsMutable(int capacity) { + if (!vector_.isModifiable()) { + vector_ = makeMutableCopy(vector_, capacity); + } + bitField0_ |= 0x00000002; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return A list containing the vector. + */ + @java.lang.Deprecated public java.util.List + getVectorList() { + vector_.makeImmutable(); + return vector_; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return The count of vector. + */ + @java.lang.Deprecated public int getVectorCount() { + return vector_.size(); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated public float getVector(int index) { + return vector_.getFloat(index); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param index The index to set the value at. + * @param value The vector to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setVector( + int index, float value) { + + ensureVectorIsMutable(); + vector_.setFloat(index, value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param value The vector to add. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder addVector(float value) { + + ensureVectorIsMutable(); + vector_.addFloat(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @param values The vector to add. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder addAllVector( + java.lang.Iterable values) { + ensureVectorIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, vector_); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.BatchObject.vector is deprecated. + * See v1/batch.proto;l=103 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearVector() { + vector_ = emptyFloatList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties properties_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder> propertiesBuilder_; + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return Whether the properties field is set. + */ + public boolean hasProperties() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + * @return The properties. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties getProperties() { + if (propertiesBuilder_ == null) { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; + } else { + return propertiesBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public Builder setProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + properties_ = value; + } else { + propertiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public Builder setProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder builderForValue) { + if (propertiesBuilder_ == null) { + properties_ = builderForValue.build(); + } else { + propertiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public Builder mergeProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties value) { + if (propertiesBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + properties_ != null && + properties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance()) { + getPropertiesBuilder().mergeFrom(value); + } else { + properties_ = value; + } + } else { + propertiesBuilder_.mergeFrom(value); + } + if (properties_ != null) { + bitField0_ |= 0x00000004; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public Builder clearProperties() { + bitField0_ = (bitField0_ & ~0x00000004); + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder getPropertiesBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getPropertiesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder getPropertiesOrBuilder() { + if (propertiesBuilder_ != null) { + return propertiesBuilder_.getMessageOrBuilder(); + } else { + return properties_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.getDefaultInstance() : properties_; + } + } + /** + * .weaviate.v1.BatchObject.Properties properties = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder> + getPropertiesFieldBuilder() { + if (propertiesBuilder_ == null) { + propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject.PropertiesOrBuilder>( + getProperties(), + getParentForChildren(), + isClean()); + properties_ = null; + } + return propertiesBuilder_; + } + + private java.lang.Object collection_ = ""; + /** + * string collection = 4; + * @return The collection. + */ + public java.lang.String getCollection() { + java.lang.Object ref = collection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + collection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string collection = 4; + * @return The bytes for collection. + */ + public com.google.protobuf.ByteString + getCollectionBytes() { + java.lang.Object ref = collection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + collection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string collection = 4; + * @param value The collection to set. + * @return This builder for chaining. + */ + public Builder setCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + collection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * string collection = 4; + * @return This builder for chaining. + */ + public Builder clearCollection() { + collection_ = getDefaultInstance().getCollection(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + /** + * string collection = 4; + * @param value The bytes for collection to set. + * @return This builder for chaining. + */ + public Builder setCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + collection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + + private java.lang.Object tenant_ = ""; + /** + * string tenant = 5; + * @return The tenant. + */ + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string tenant = 5; + * @return The bytes for tenant. + */ + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string tenant = 5; + * @param value The tenant to set. + * @return This builder for chaining. + */ + public Builder setTenant( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + tenant_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * string tenant = 5; + * @return This builder for chaining. + */ + public Builder clearTenant() { + tenant_ = getDefaultInstance().getTenant(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + return this; + } + /** + * string tenant = 5; + * @param value The bytes for tenant to set. + * @return This builder for chaining. + */ + public Builder setTenantBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + tenant_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes vector_bytes = 6; + * @return The vectorBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getVectorBytes() { + return vectorBytes_; + } + /** + * bytes vector_bytes = 6; + * @param value The vectorBytes to set. + * @return This builder for chaining. + */ + public Builder setVectorBytes(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + vectorBytes_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * bytes vector_bytes = 6; + * @return This builder for chaining. + */ + public Builder clearVectorBytes() { + bitField0_ = (bitField0_ & ~0x00000020); + vectorBytes_ = getDefaultInstance().getVectorBytes(); + onChanged(); + return this; + } + + private java.util.List vectors_ = + java.util.Collections.emptyList(); + private void ensureVectorsIsMutable() { + if (!((bitField0_ & 0x00000040) != 0)) { + vectors_ = new java.util.ArrayList(vectors_); + bitField0_ |= 0x00000040; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_; + + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List getVectorsList() { + if (vectorsBuilder_ == null) { + return java.util.Collections.unmodifiableList(vectors_); + } else { + return vectorsBuilder_.getMessageList(); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public int getVectorsCount() { + if (vectorsBuilder_ == null) { + return vectors_.size(); + } else { + return vectorsBuilder_.getCount(); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) { + if (vectorsBuilder_ == null) { + return vectors_.get(index); + } else { + return vectorsBuilder_.getMessage(index); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder setVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.set(index, value); + onChanged(); + } else { + vectorsBuilder_.setMessage(index, value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder setVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.set(index, builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.add(value); + onChanged(); + } else { + vectorsBuilder_.addMessage(value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.add(index, value); + onChanged(); + } else { + vectorsBuilder_.addMessage(index, value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(index, builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addAllVectors( + java.lang.Iterable values) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, vectors_); + onChanged(); + } else { + vectorsBuilder_.addAllMessages(values); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder clearVectors() { + if (vectorsBuilder_ == null) { + vectors_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + } else { + vectorsBuilder_.clear(); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder removeVectors(int index) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.remove(index); + onChanged(); + } else { + vectorsBuilder_.remove(index); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder getVectorsBuilder( + int index) { + return getVectorsFieldBuilder().getBuilder(index); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index) { + if (vectorsBuilder_ == null) { + return vectors_.get(index); } else { + return vectorsBuilder_.getMessageOrBuilder(index); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List + getVectorsOrBuilderList() { + if (vectorsBuilder_ != null) { + return vectorsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(vectors_); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() { + return getVectorsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance()); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder( + int index) { + return getVectorsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance()); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List + getVectorsBuilderList() { + return getVectorsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> + getVectorsFieldBuilder() { + if (vectorsBuilder_ == null) { + vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder>( + vectors_, + ((bitField0_ & 0x00000040) != 0), + getParentForChildren(), + isClean()); + vectors_ = null; + } + return vectorsBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObject) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObject) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface BatchReferenceOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReference) + com.google.protobuf.MessageOrBuilder { + + /** + * string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * string from_collection = 2; + * @return The fromCollection. + */ + java.lang.String getFromCollection(); + /** + * string from_collection = 2; + * @return The bytes for fromCollection. + */ + com.google.protobuf.ByteString + getFromCollectionBytes(); + + /** + * string from_uuid = 3; + * @return The fromUuid. + */ + java.lang.String getFromUuid(); + /** + * string from_uuid = 3; + * @return The bytes for fromUuid. + */ + com.google.protobuf.ByteString + getFromUuidBytes(); + + /** + * optional string to_collection = 4; + * @return Whether the toCollection field is set. + */ + boolean hasToCollection(); + /** + * optional string to_collection = 4; + * @return The toCollection. + */ + java.lang.String getToCollection(); + /** + * optional string to_collection = 4; + * @return The bytes for toCollection. + */ + com.google.protobuf.ByteString + getToCollectionBytes(); + + /** + * string to_uuid = 5; + * @return The toUuid. + */ + java.lang.String getToUuid(); + /** + * string to_uuid = 5; + * @return The bytes for toUuid. + */ + com.google.protobuf.ByteString + getToUuidBytes(); + + /** + * string tenant = 6; + * @return The tenant. + */ + java.lang.String getTenant(); + /** + * string tenant = 6; + * @return The bytes for tenant. + */ + com.google.protobuf.ByteString + getTenantBytes(); + } + /** + * Protobuf type {@code weaviate.v1.BatchReference} + */ + public static final class BatchReference extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReference) + BatchReferenceOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchReference.newBuilder() to construct. + private BatchReference(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchReference() { + name_ = ""; + fromCollection_ = ""; + fromUuid_ = ""; + toCollection_ = ""; + toUuid_ = ""; + tenant_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchReference(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object name_ = ""; + /** + * string name = 1; + * @return The name. + */ + @java.lang.Override + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 1; + * @return The bytes for name. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FROM_COLLECTION_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object fromCollection_ = ""; + /** + * string from_collection = 2; + * @return The fromCollection. + */ + @java.lang.Override + public java.lang.String getFromCollection() { + java.lang.Object ref = fromCollection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fromCollection_ = s; + return s; + } + } + /** + * string from_collection = 2; + * @return The bytes for fromCollection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getFromCollectionBytes() { + java.lang.Object ref = fromCollection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fromCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FROM_UUID_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object fromUuid_ = ""; + /** + * string from_uuid = 3; + * @return The fromUuid. + */ + @java.lang.Override + public java.lang.String getFromUuid() { + java.lang.Object ref = fromUuid_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fromUuid_ = s; + return s; + } + } + /** + * string from_uuid = 3; + * @return The bytes for fromUuid. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getFromUuidBytes() { + java.lang.Object ref = fromUuid_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fromUuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TO_COLLECTION_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private volatile java.lang.Object toCollection_ = ""; + /** + * optional string to_collection = 4; + * @return Whether the toCollection field is set. + */ + @java.lang.Override + public boolean hasToCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string to_collection = 4; + * @return The toCollection. + */ + @java.lang.Override + public java.lang.String getToCollection() { + java.lang.Object ref = toCollection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + toCollection_ = s; + return s; + } + } + /** + * optional string to_collection = 4; + * @return The bytes for toCollection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getToCollectionBytes() { + java.lang.Object ref = toCollection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + toCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TO_UUID_FIELD_NUMBER = 5; + @SuppressWarnings("serial") + private volatile java.lang.Object toUuid_ = ""; + /** + * string to_uuid = 5; + * @return The toUuid. + */ + @java.lang.Override + public java.lang.String getToUuid() { + java.lang.Object ref = toUuid_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + toUuid_ = s; + return s; + } + } + /** + * string to_uuid = 5; + * @return The bytes for toUuid. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getToUuidBytes() { + java.lang.Object ref = toUuid_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + toUuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TENANT_FIELD_NUMBER = 6; + @SuppressWarnings("serial") + private volatile java.lang.Object tenant_ = ""; + /** + * string tenant = 6; + * @return The tenant. + */ + @java.lang.Override + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } + } + /** + * string tenant = 6; + * @return The bytes for tenant. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromCollection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, fromCollection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromUuid_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fromUuid_); + } + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, toCollection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(toUuid_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 5, toUuid_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, tenant_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromCollection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, fromCollection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fromUuid_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fromUuid_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, toCollection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(toUuid_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, toUuid_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, tenant_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference) obj; + + if (!getName() + .equals(other.getName())) return false; + if (!getFromCollection() + .equals(other.getFromCollection())) return false; + if (!getFromUuid() + .equals(other.getFromUuid())) return false; + if (hasToCollection() != other.hasToCollection()) return false; + if (hasToCollection()) { + if (!getToCollection() + .equals(other.getToCollection())) return false; + } + if (!getToUuid() + .equals(other.getToUuid())) return false; + if (!getTenant() + .equals(other.getTenant())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + FROM_COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getFromCollection().hashCode(); + hash = (37 * hash) + FROM_UUID_FIELD_NUMBER; + hash = (53 * hash) + getFromUuid().hashCode(); + if (hasToCollection()) { + hash = (37 * hash) + TO_COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getToCollection().hashCode(); + } + hash = (37 * hash) + TO_UUID_FIELD_NUMBER; + hash = (53 * hash) + getToUuid().hashCode(); + hash = (37 * hash) + TENANT_FIELD_NUMBER; + hash = (53 * hash) + getTenant().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchReference} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReference) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferenceOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + name_ = ""; + fromCollection_ = ""; + fromUuid_ = ""; + toCollection_ = ""; + toUuid_ = ""; + tenant_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReference_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.name_ = name_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.fromCollection_ = fromCollection_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.fromUuid_ = fromUuid_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000008) != 0)) { + result.toCollection_ = toCollection_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.toUuid_ = toUuid_; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.tenant_ = tenant_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getFromCollection().isEmpty()) { + fromCollection_ = other.fromCollection_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getFromUuid().isEmpty()) { + fromUuid_ = other.fromUuid_; + bitField0_ |= 0x00000004; + onChanged(); + } + if (other.hasToCollection()) { + toCollection_ = other.toCollection_; + bitField0_ |= 0x00000008; + onChanged(); + } + if (!other.getToUuid().isEmpty()) { + toUuid_ = other.toUuid_; + bitField0_ |= 0x00000010; + onChanged(); + } + if (!other.getTenant().isEmpty()) { + tenant_ = other.tenant_; + bitField0_ |= 0x00000020; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + name_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + fromCollection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + fromUuid_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 34: { + toCollection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000008; + break; + } // case 34 + case 42: { + toUuid_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000010; + break; + } // case 42 + case 50: { + tenant_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000020; + break; + } // case 50 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + name_ = getDefaultInstance().getName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object fromCollection_ = ""; + /** + * string from_collection = 2; + * @return The fromCollection. + */ + public java.lang.String getFromCollection() { + java.lang.Object ref = fromCollection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fromCollection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string from_collection = 2; + * @return The bytes for fromCollection. + */ + public com.google.protobuf.ByteString + getFromCollectionBytes() { + java.lang.Object ref = fromCollection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fromCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string from_collection = 2; + * @param value The fromCollection to set. + * @return This builder for chaining. + */ + public Builder setFromCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + fromCollection_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string from_collection = 2; + * @return This builder for chaining. + */ + public Builder clearFromCollection() { + fromCollection_ = getDefaultInstance().getFromCollection(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string from_collection = 2; + * @param value The bytes for fromCollection to set. + * @return This builder for chaining. + */ + public Builder setFromCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + fromCollection_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object fromUuid_ = ""; + /** + * string from_uuid = 3; + * @return The fromUuid. + */ + public java.lang.String getFromUuid() { + java.lang.Object ref = fromUuid_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fromUuid_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string from_uuid = 3; + * @return The bytes for fromUuid. + */ + public com.google.protobuf.ByteString + getFromUuidBytes() { + java.lang.Object ref = fromUuid_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fromUuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string from_uuid = 3; + * @param value The fromUuid to set. + * @return This builder for chaining. + */ + public Builder setFromUuid( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + fromUuid_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string from_uuid = 3; + * @return This builder for chaining. + */ + public Builder clearFromUuid() { + fromUuid_ = getDefaultInstance().getFromUuid(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string from_uuid = 3; + * @param value The bytes for fromUuid to set. + * @return This builder for chaining. + */ + public Builder setFromUuidBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + fromUuid_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + + private java.lang.Object toCollection_ = ""; + /** + * optional string to_collection = 4; + * @return Whether the toCollection field is set. + */ + public boolean hasToCollection() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional string to_collection = 4; + * @return The toCollection. + */ + public java.lang.String getToCollection() { + java.lang.Object ref = toCollection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + toCollection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string to_collection = 4; + * @return The bytes for toCollection. + */ + public com.google.protobuf.ByteString + getToCollectionBytes() { + java.lang.Object ref = toCollection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + toCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string to_collection = 4; + * @param value The toCollection to set. + * @return This builder for chaining. + */ + public Builder setToCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + toCollection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * optional string to_collection = 4; + * @return This builder for chaining. + */ + public Builder clearToCollection() { + toCollection_ = getDefaultInstance().getToCollection(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + /** + * optional string to_collection = 4; + * @param value The bytes for toCollection to set. + * @return This builder for chaining. + */ + public Builder setToCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + toCollection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + + private java.lang.Object toUuid_ = ""; + /** + * string to_uuid = 5; + * @return The toUuid. + */ + public java.lang.String getToUuid() { + java.lang.Object ref = toUuid_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + toUuid_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string to_uuid = 5; + * @return The bytes for toUuid. + */ + public com.google.protobuf.ByteString + getToUuidBytes() { + java.lang.Object ref = toUuid_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + toUuid_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string to_uuid = 5; + * @param value The toUuid to set. + * @return This builder for chaining. + */ + public Builder setToUuid( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + toUuid_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * string to_uuid = 5; + * @return This builder for chaining. + */ + public Builder clearToUuid() { + toUuid_ = getDefaultInstance().getToUuid(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + return this; + } + /** + * string to_uuid = 5; + * @param value The bytes for toUuid to set. + * @return This builder for chaining. + */ + public Builder setToUuidBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + toUuid_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + + private java.lang.Object tenant_ = ""; + /** + * string tenant = 6; + * @return The tenant. + */ + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string tenant = 6; + * @return The bytes for tenant. + */ + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string tenant = 6; + * @param value The tenant to set. + * @return This builder for chaining. + */ + public Builder setTenant( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + tenant_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * string tenant = 6; + * @return This builder for chaining. + */ + public Builder clearTenant() { + tenant_ = getDefaultInstance().getTenant(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + /** + * string tenant = 6; + * @param value The bytes for tenant to set. + * @return This builder for chaining. + */ + public Builder setTenantBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + tenant_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReference) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReference) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchReference parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReference getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface BatchObjectsReplyOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsReply) + com.google.protobuf.MessageOrBuilder { + + /** + * float took = 1; + * @return The took. + */ + float getTook(); + + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + java.util.List + getErrorsList(); + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index); + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + int getErrorsCount(); + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + java.util.List + getErrorsOrBuilderList(); + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.BatchObjectsReply} + */ + public static final class BatchObjectsReply extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsReply) + BatchObjectsReplyOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchObjectsReply.newBuilder() to construct. + private BatchObjectsReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchObjectsReply() { + errors_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchObjectsReply(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.Builder.class); + } + + public interface BatchErrorOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchObjectsReply.BatchError) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 index = 1; + * @return The index. + */ + int getIndex(); + + /** + * string error = 2; + * @return The error. + */ + java.lang.String getError(); + /** + * string error = 2; + * @return The bytes for error. + */ + com.google.protobuf.ByteString + getErrorBytes(); + } + /** + * Protobuf type {@code weaviate.v1.BatchObjectsReply.BatchError} + */ + public static final class BatchError extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchObjectsReply.BatchError) + BatchErrorOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchError.newBuilder() to construct. + private BatchError(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchError() { + error_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchError(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder.class); + } + + public static final int INDEX_FIELD_NUMBER = 1; + private int index_ = 0; + /** + * int32 index = 1; + * @return The index. + */ + @java.lang.Override + public int getIndex() { + return index_; + } + + public static final int ERROR_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object error_ = ""; + /** + * string error = 2; + * @return The error. + */ + @java.lang.Override + public java.lang.String getError() { + java.lang.Object ref = error_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + error_ = s; + return s; + } + } + /** + * string error = 2; + * @return The bytes for error. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getErrorBytes() { + java.lang.Object ref = error_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + error_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (index_ != 0) { + output.writeInt32(1, index_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, error_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (index_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, index_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, error_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError) obj; + + if (getIndex() + != other.getIndex()) return false; + if (!getError() + .equals(other.getError())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_FIELD_NUMBER; + hash = (53 * hash) + getIndex(); + hash = (37 * hash) + ERROR_FIELD_NUMBER; + hash = (53 * hash) + getError().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObjectsReply.BatchError} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsReply.BatchError) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + index_ = 0; + error_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.index_ = index_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.error_ = error_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()) return this; + if (other.getIndex() != 0) { + setIndex(other.getIndex()); + } + if (!other.getError().isEmpty()) { + error_ = other.error_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + index_ = input.readInt32(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 18: { + error_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private int index_ ; + /** + * int32 index = 1; + * @return The index. + */ + @java.lang.Override + public int getIndex() { + return index_; + } + /** + * int32 index = 1; + * @param value The index to set. + * @return This builder for chaining. + */ + public Builder setIndex(int value) { + + index_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * int32 index = 1; + * @return This builder for chaining. + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0; + onChanged(); + return this; + } + + private java.lang.Object error_ = ""; + /** + * string error = 2; + * @return The error. + */ + public java.lang.String getError() { + java.lang.Object ref = error_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + error_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string error = 2; + * @return The bytes for error. + */ + public com.google.protobuf.ByteString + getErrorBytes() { + java.lang.Object ref = error_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + error_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string error = 2; + * @param value The error to set. + * @return This builder for chaining. + */ + public Builder setError( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + error_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string error = 2; + * @return This builder for chaining. + */ + public Builder clearError() { + error_ = getDefaultInstance().getError(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string error = 2; + * @param value The bytes for error to set. + * @return This builder for chaining. + */ + public Builder setErrorBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + error_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsReply.BatchError) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsReply.BatchError) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchError parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int TOOK_FIELD_NUMBER = 1; + private float took_ = 0F; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + + public static final int ERRORS_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List errors_; + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + @java.lang.Override + public java.util.List getErrorsList() { + return errors_; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + @java.lang.Override + public java.util.List + getErrorsOrBuilderList() { + return errors_; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + @java.lang.Override + public int getErrorsCount() { + return errors_.size(); + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index) { + return errors_.get(index); + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index) { + return errors_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + output.writeFloat(1, took_); + } + for (int i = 0; i < errors_.size(); i++) { + output.writeMessage(2, errors_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(1, took_); + } + for (int i = 0; i < errors_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, errors_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply) obj; + + if (java.lang.Float.floatToIntBits(getTook()) + != java.lang.Float.floatToIntBits( + other.getTook())) return false; + if (!getErrorsList() + .equals(other.getErrorsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TOOK_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getTook()); + if (getErrorsCount() > 0) { + hash = (37 * hash) + ERRORS_FIELD_NUMBER; + hash = (53 * hash) + getErrorsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchObjectsReply} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchObjectsReply) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReplyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + took_ = 0F; + if (errorsBuilder_ == null) { + errors_ = java.util.Collections.emptyList(); + } else { + errors_ = null; + errorsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchObjectsReply_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply result) { + if (errorsBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + errors_ = java.util.Collections.unmodifiableList(errors_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.errors_ = errors_; + } else { + result.errors_ = errorsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.took_ = took_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.getDefaultInstance()) return this; + if (other.getTook() != 0F) { + setTook(other.getTook()); + } + if (errorsBuilder_ == null) { + if (!other.errors_.isEmpty()) { + if (errors_.isEmpty()) { + errors_ = other.errors_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureErrorsIsMutable(); + errors_.addAll(other.errors_); + } + onChanged(); + } + } else { + if (!other.errors_.isEmpty()) { + if (errorsBuilder_.isEmpty()) { + errorsBuilder_.dispose(); + errorsBuilder_ = null; + errors_ = other.errors_; + bitField0_ = (bitField0_ & ~0x00000002); + errorsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getErrorsFieldBuilder() : null; + } else { + errorsBuilder_.addAllMessages(other.errors_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 13: { + took_ = input.readFloat(); + bitField0_ |= 0x00000001; + break; + } // case 13 + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.parser(), + extensionRegistry); + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(m); + } else { + errorsBuilder_.addMessage(m); + } + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private float took_ ; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + /** + * float took = 1; + * @param value The took to set. + * @return This builder for chaining. + */ + public Builder setTook(float value) { + + took_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * float took = 1; + * @return This builder for chaining. + */ + public Builder clearTook() { + bitField0_ = (bitField0_ & ~0x00000001); + took_ = 0F; + onChanged(); + return this; + } + + private java.util.List errors_ = + java.util.Collections.emptyList(); + private void ensureErrorsIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + errors_ = new java.util.ArrayList(errors_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder> errorsBuilder_; + + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public java.util.List getErrorsList() { + if (errorsBuilder_ == null) { + return java.util.Collections.unmodifiableList(errors_); + } else { + return errorsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public int getErrorsCount() { + if (errorsBuilder_ == null) { + return errors_.size(); + } else { + return errorsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError getErrors(int index) { + if (errorsBuilder_ == null) { + return errors_.get(index); + } else { + return errorsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder setErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.set(index, value); + onChanged(); + } else { + errorsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder setErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.set(index, builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder addErrors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.add(value); + onChanged(); + } else { + errorsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder addErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.add(index, value); + onChanged(); + } else { + errorsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder addErrors( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder addErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(index, builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder addAllErrors( + java.lang.Iterable values) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, errors_); + onChanged(); + } else { + errorsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder clearErrors() { + if (errorsBuilder_ == null) { + errors_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + errorsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public Builder removeErrors(int index) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.remove(index); + onChanged(); + } else { + errorsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder getErrorsBuilder( + int index) { + return getErrorsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index) { + if (errorsBuilder_ == null) { + return errors_.get(index); } else { + return errorsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public java.util.List + getErrorsOrBuilderList() { + if (errorsBuilder_ != null) { + return errorsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(errors_); + } + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder addErrorsBuilder() { + return getErrorsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder addErrorsBuilder( + int index) { + return getErrorsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchObjectsReply.BatchError errors = 2; + */ + public java.util.List + getErrorsBuilderList() { + return getErrorsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder> + getErrorsFieldBuilder() { + if (errorsBuilder_ == null) { + errorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply.BatchErrorOrBuilder>( + errors_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + errors_ = null; + } + return errorsBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchObjectsReply) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchObjectsReply) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchObjectsReply parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchObjectsReply getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface BatchReferencesReplyOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesReply) + com.google.protobuf.MessageOrBuilder { + + /** + * float took = 1; + * @return The took. + */ + float getTook(); + + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + java.util.List + getErrorsList(); + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index); + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + int getErrorsCount(); + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + java.util.List + getErrorsOrBuilderList(); + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.BatchReferencesReply} + */ + public static final class BatchReferencesReply extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesReply) + BatchReferencesReplyOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchReferencesReply.newBuilder() to construct. + private BatchReferencesReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchReferencesReply() { + errors_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchReferencesReply(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.Builder.class); + } + + public interface BatchErrorOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BatchReferencesReply.BatchError) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 index = 1; + * @return The index. + */ + int getIndex(); + + /** + * string error = 2; + * @return The error. + */ + java.lang.String getError(); + /** + * string error = 2; + * @return The bytes for error. + */ + com.google.protobuf.ByteString + getErrorBytes(); + } + /** + * Protobuf type {@code weaviate.v1.BatchReferencesReply.BatchError} + */ + public static final class BatchError extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BatchReferencesReply.BatchError) + BatchErrorOrBuilder { + private static final long serialVersionUID = 0L; + // Use BatchError.newBuilder() to construct. + private BatchError(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BatchError() { + error_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BatchError(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder.class); + } + + public static final int INDEX_FIELD_NUMBER = 1; + private int index_ = 0; + /** + * int32 index = 1; + * @return The index. + */ + @java.lang.Override + public int getIndex() { + return index_; + } + + public static final int ERROR_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object error_ = ""; + /** + * string error = 2; + * @return The error. + */ + @java.lang.Override + public java.lang.String getError() { + java.lang.Object ref = error_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + error_ = s; + return s; + } + } + /** + * string error = 2; + * @return The bytes for error. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getErrorBytes() { + java.lang.Object ref = error_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + error_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (index_ != 0) { + output.writeInt32(1, index_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, error_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (index_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, index_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(error_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, error_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError) obj; + + if (getIndex() + != other.getIndex()) return false; + if (!getError() + .equals(other.getError())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_FIELD_NUMBER; + hash = (53 * hash) + getIndex(); + hash = (37 * hash) + ERROR_FIELD_NUMBER; + hash = (53 * hash) + getError().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchReferencesReply.BatchError} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesReply.BatchError) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + index_ = 0; + error_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.index_ = index_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.error_ = error_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()) return this; + if (other.getIndex() != 0) { + setIndex(other.getIndex()); + } + if (!other.getError().isEmpty()) { + error_ = other.error_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + index_ = input.readInt32(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 18: { + error_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private int index_ ; + /** + * int32 index = 1; + * @return The index. + */ + @java.lang.Override + public int getIndex() { + return index_; + } + /** + * int32 index = 1; + * @param value The index to set. + * @return This builder for chaining. + */ + public Builder setIndex(int value) { + + index_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * int32 index = 1; + * @return This builder for chaining. + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000001); + index_ = 0; + onChanged(); + return this; + } + + private java.lang.Object error_ = ""; + /** + * string error = 2; + * @return The error. + */ + public java.lang.String getError() { + java.lang.Object ref = error_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + error_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string error = 2; + * @return The bytes for error. + */ + public com.google.protobuf.ByteString + getErrorBytes() { + java.lang.Object ref = error_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + error_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string error = 2; + * @param value The error to set. + * @return This builder for chaining. + */ + public Builder setError( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + error_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string error = 2; + * @return This builder for chaining. + */ + public Builder clearError() { + error_ = getDefaultInstance().getError(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string error = 2; + * @param value The bytes for error to set. + * @return This builder for chaining. + */ + public Builder setErrorBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + error_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesReply.BatchError) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesReply.BatchError) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchError parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int TOOK_FIELD_NUMBER = 1; + private float took_ = 0F; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + + public static final int ERRORS_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List errors_; + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + @java.lang.Override + public java.util.List getErrorsList() { + return errors_; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + @java.lang.Override + public java.util.List + getErrorsOrBuilderList() { + return errors_; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + @java.lang.Override + public int getErrorsCount() { + return errors_.size(); + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index) { + return errors_.get(index); + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index) { + return errors_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + output.writeFloat(1, took_); + } + for (int i = 0; i < errors_.size(); i++) { + output.writeMessage(2, errors_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(1, took_); + } + for (int i = 0; i < errors_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, errors_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply) obj; + + if (java.lang.Float.floatToIntBits(getTook()) + != java.lang.Float.floatToIntBits( + other.getTook())) return false; + if (!getErrorsList() + .equals(other.getErrorsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TOOK_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getTook()); + if (getErrorsCount() > 0) { + hash = (37 * hash) + ERRORS_FIELD_NUMBER; + hash = (53 * hash) + getErrorsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BatchReferencesReply} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchReferencesReply) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReplyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + took_ = 0F; + if (errorsBuilder_ == null) { + errors_ = java.util.Collections.emptyList(); + } else { + errors_ = null; + errorsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.internal_static_weaviate_v1_BatchReferencesReply_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply result) { + if (errorsBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + errors_ = java.util.Collections.unmodifiableList(errors_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.errors_ = errors_; + } else { + result.errors_ = errorsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.took_ = took_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.getDefaultInstance()) return this; + if (other.getTook() != 0F) { + setTook(other.getTook()); + } + if (errorsBuilder_ == null) { + if (!other.errors_.isEmpty()) { + if (errors_.isEmpty()) { + errors_ = other.errors_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureErrorsIsMutable(); + errors_.addAll(other.errors_); + } + onChanged(); + } + } else { + if (!other.errors_.isEmpty()) { + if (errorsBuilder_.isEmpty()) { + errorsBuilder_.dispose(); + errorsBuilder_ = null; + errors_ = other.errors_; + bitField0_ = (bitField0_ & ~0x00000002); + errorsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getErrorsFieldBuilder() : null; + } else { + errorsBuilder_.addAllMessages(other.errors_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 13: { + took_ = input.readFloat(); + bitField0_ |= 0x00000001; + break; + } // case 13 + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.parser(), + extensionRegistry); + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(m); + } else { + errorsBuilder_.addMessage(m); + } + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private float took_ ; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + /** + * float took = 1; + * @param value The took to set. + * @return This builder for chaining. + */ + public Builder setTook(float value) { + + took_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * float took = 1; + * @return This builder for chaining. + */ + public Builder clearTook() { + bitField0_ = (bitField0_ & ~0x00000001); + took_ = 0F; + onChanged(); + return this; + } + + private java.util.List errors_ = + java.util.Collections.emptyList(); + private void ensureErrorsIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + errors_ = new java.util.ArrayList(errors_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder> errorsBuilder_; + + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public java.util.List getErrorsList() { + if (errorsBuilder_ == null) { + return java.util.Collections.unmodifiableList(errors_); + } else { + return errorsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public int getErrorsCount() { + if (errorsBuilder_ == null) { + return errors_.size(); + } else { + return errorsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError getErrors(int index) { + if (errorsBuilder_ == null) { + return errors_.get(index); + } else { + return errorsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder setErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.set(index, value); + onChanged(); + } else { + errorsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder setErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.set(index, builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder addErrors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.add(value); + onChanged(); + } else { + errorsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder addErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError value) { + if (errorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureErrorsIsMutable(); + errors_.add(index, value); + onChanged(); + } else { + errorsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder addErrors( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder addErrors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder builderForValue) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.add(index, builderForValue.build()); + onChanged(); + } else { + errorsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder addAllErrors( + java.lang.Iterable values) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, errors_); + onChanged(); + } else { + errorsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder clearErrors() { + if (errorsBuilder_ == null) { + errors_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + errorsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public Builder removeErrors(int index) { + if (errorsBuilder_ == null) { + ensureErrorsIsMutable(); + errors_.remove(index); + onChanged(); + } else { + errorsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder getErrorsBuilder( + int index) { + return getErrorsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder getErrorsOrBuilder( + int index) { + if (errorsBuilder_ == null) { + return errors_.get(index); } else { + return errorsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public java.util.List + getErrorsOrBuilderList() { + if (errorsBuilder_ != null) { + return errorsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(errors_); + } + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder addErrorsBuilder() { + return getErrorsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder addErrorsBuilder( + int index) { + return getErrorsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.BatchReferencesReply.BatchError errors = 2; + */ + public java.util.List + getErrorsBuilderList() { + return getErrorsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder> + getErrorsFieldBuilder() { + if (errorsBuilder_ == null) { + errorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchError.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply.BatchErrorOrBuilder>( + errors_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + errors_ = null; + } + return errorsBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BatchReferencesReply) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BatchReferencesReply) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BatchReferencesReply parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch.BatchReferencesReply getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObjectsRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchReferencesRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchSendRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchSendRequest_References_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchSendReply_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObject_Properties_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchReference_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchReference_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObjectsReply_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchReferencesReply_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\016v1/batch.proto\022\013weaviate.v1\032\034google/pr" + + "otobuf/struct.proto\032\rv1/base.proto\"\225\001\n\023B" + + "atchObjectsRequest\022)\n\007objects\030\001 \003(\0132\030.we" + + "aviate.v1.BatchObject\022=\n\021consistency_lev" + + "el\030\002 \001(\0162\035.weaviate.v1.ConsistencyLevelH" + + "\000\210\001\001B\024\n\022_consistency_level\"\236\001\n\026BatchRefe" + + "rencesRequest\022/\n\nreferences\030\001 \003(\0132\033.weav" + + "iate.v1.BatchReference\022=\n\021consistency_le" + + "vel\030\002 \001(\0162\035.weaviate.v1.ConsistencyLevel" + + "H\000\210\001\001B\024\n\022_consistency_level\"\326\002\n\020BatchSen" + + "dRequest\022\021\n\tstream_id\030\001 \001(\t\0228\n\007objects\030\002" + + " \001(\0132%.weaviate.v1.BatchSendRequest.Obje" + + "ctsH\000\022>\n\nreferences\030\003 \001(\0132(.weaviate.v1." + + "BatchSendRequest.ReferencesH\000\0222\n\004stop\030\004 " + + "\001(\0132\".weaviate.v1.BatchSendRequest.StopH" + + "\000\032\006\n\004Stop\0323\n\007Objects\022(\n\006values\030\001 \003(\0132\030.w" + + "eaviate.v1.BatchObject\0329\n\nReferences\022+\n\006" + + "values\030\001 \003(\0132\033.weaviate.v1.BatchReferenc" + + "eB\t\n\007message\"B\n\016BatchSendReply\022\027\n\017next_b" + + "atch_size\030\001 \001(\005\022\027\n\017backoff_seconds\030\002 \001(\002" + + "\"\307\001\n\022BatchStreamRequest\022=\n\021consistency_l" + + "evel\030\001 \001(\0162\035.weaviate.v1.ConsistencyLeve" + + "lH\000\210\001\001\022\031\n\014object_index\030\002 \001(\005H\001\210\001\001\022\034\n\017ref" + + "erence_index\030\003 \001(\005H\002\210\001\001B\024\n\022_consistency_" + + "levelB\017\n\r_object_indexB\022\n\020_reference_ind" + + "ex\"\360\003\n\022BatchStreamMessage\022\021\n\tstream_id\030\001" + + " \001(\t\0226\n\005error\030\002 \001(\0132%.weaviate.v1.BatchS" + + "treamMessage.ErrorH\000\0226\n\005start\030\003 \001(\0132%.we" + + "aviate.v1.BatchStreamMessage.StartH\000\0224\n\004" + + "stop\030\004 \001(\0132$.weaviate.v1.BatchStreamMess" + + "age.StopH\000\022<\n\010shutdown\030\005 \001(\0132(.weaviate." + + "v1.BatchStreamMessage.ShutdownH\000\022E\n\rshut" + + "ting_down\030\006 \001(\0132,.weaviate.v1.BatchStrea" + + "mMessage.ShuttingDownH\000\032\007\n\005Start\032\006\n\004Stop" + + "\032\n\n\010Shutdown\032\016\n\014ShuttingDown\032d\n\005Error\022\r\n" + + "\005error\030\001 \001(\t\022\r\n\005index\030\002 \001(\005\022\024\n\014is_retria" + + "ble\030\003 \001(\010\022\021\n\tis_object\030\004 \001(\010\022\024\n\014is_refer" + + "ence\030\005 \001(\010B\t\n\007message\"\336\007\n\013BatchObject\022\014\n" + + "\004uuid\030\001 \001(\t\022\022\n\006vector\030\002 \003(\002B\002\030\001\0227\n\nprope" + + "rties\030\003 \001(\0132#.weaviate.v1.BatchObject.Pr" + + "operties\022\022\n\ncollection\030\004 \001(\t\022\016\n\006tenant\030\005" + + " \001(\t\022\024\n\014vector_bytes\030\006 \001(\014\022%\n\007vectors\030\027 " + + "\003(\0132\024.weaviate.v1.Vectors\032\204\005\n\nProperties" + + "\0223\n\022non_ref_properties\030\001 \001(\0132\027.google.pr" + + "otobuf.Struct\022N\n\027single_target_ref_props" + + "\030\002 \003(\0132-.weaviate.v1.BatchObject.SingleT" + + "argetRefProps\022L\n\026multi_target_ref_props\030" + + "\003 \003(\0132,.weaviate.v1.BatchObject.MultiTar" + + "getRefProps\022C\n\027number_array_properties\030\004" + + " \003(\0132\".weaviate.v1.NumberArrayProperties" + + "\022=\n\024int_array_properties\030\005 \003(\0132\037.weaviat" + + "e.v1.IntArrayProperties\022?\n\025text_array_pr" + + "operties\030\006 \003(\0132 .weaviate.v1.TextArrayPr" + + "operties\022E\n\030boolean_array_properties\030\007 \003" + + "(\0132#.weaviate.v1.BooleanArrayProperties\022" + + "8\n\021object_properties\030\010 \003(\0132\035.weaviate.v1" + + ".ObjectProperties\022C\n\027object_array_proper" + + "ties\030\t \003(\0132\".weaviate.v1.ObjectArrayProp" + + "erties\022\030\n\020empty_list_props\030\n \003(\t\0328\n\024Sing" + + "leTargetRefProps\022\r\n\005uuids\030\001 \003(\t\022\021\n\tprop_" + + "name\030\002 \001(\t\032R\n\023MultiTargetRefProps\022\r\n\005uui" + + "ds\030\001 \003(\t\022\021\n\tprop_name\030\002 \001(\t\022\031\n\021target_co" + + "llection\030\003 \001(\t\"\231\001\n\016BatchReference\022\014\n\004nam" + + "e\030\001 \001(\t\022\027\n\017from_collection\030\002 \001(\t\022\021\n\tfrom" + + "_uuid\030\003 \001(\t\022\032\n\rto_collection\030\004 \001(\tH\000\210\001\001\022" + + "\017\n\007to_uuid\030\005 \001(\t\022\016\n\006tenant\030\006 \001(\tB\020\n\016_to_" + + "collection\"\210\001\n\021BatchObjectsReply\022\014\n\004took" + + "\030\001 \001(\002\0229\n\006errors\030\002 \003(\0132).weaviate.v1.Bat" + + "chObjectsReply.BatchError\032*\n\nBatchError\022" + + "\r\n\005index\030\001 \001(\005\022\r\n\005error\030\002 \001(\t\"\216\001\n\024BatchR" + + "eferencesReply\022\014\n\004took\030\001 \001(\002\022<\n\006errors\030\002" + + " \003(\0132,.weaviate.v1.BatchReferencesReply." + + "BatchError\032*\n\nBatchError\022\r\n\005index\030\001 \001(\005\022" + + "\r\n\005error\030\002 \001(\tBC\n-io.weaviate.client6.v1" + + ".internal.grpc.protocolB\022WeaviateProtoBa" + + "tchb\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.google.protobuf.StructProto.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(), + }); + internal_static_weaviate_v1_BatchObjectsRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_weaviate_v1_BatchObjectsRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObjectsRequest_descriptor, + new java.lang.String[] { "Objects", "ConsistencyLevel", "ConsistencyLevel", }); + internal_static_weaviate_v1_BatchReferencesRequest_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_weaviate_v1_BatchReferencesRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchReferencesRequest_descriptor, + new java.lang.String[] { "References", "ConsistencyLevel", "ConsistencyLevel", }); + internal_static_weaviate_v1_BatchSendRequest_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_weaviate_v1_BatchSendRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchSendRequest_descriptor, + new java.lang.String[] { "StreamId", "Objects", "References", "Stop", "Message", }); + internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor = + internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_BatchSendRequest_Stop_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchSendRequest_Stop_descriptor, + new java.lang.String[] { }); + internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor = + internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(1); + internal_static_weaviate_v1_BatchSendRequest_Objects_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchSendRequest_Objects_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_BatchSendRequest_References_descriptor = + internal_static_weaviate_v1_BatchSendRequest_descriptor.getNestedTypes().get(2); + internal_static_weaviate_v1_BatchSendRequest_References_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchSendRequest_References_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_BatchSendReply_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_weaviate_v1_BatchSendReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchSendReply_descriptor, + new java.lang.String[] { "NextBatchSize", "BackoffSeconds", }); + internal_static_weaviate_v1_BatchStreamRequest_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_weaviate_v1_BatchStreamRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamRequest_descriptor, + new java.lang.String[] { "ConsistencyLevel", "ObjectIndex", "ReferenceIndex", "ConsistencyLevel", "ObjectIndex", "ReferenceIndex", }); + internal_static_weaviate_v1_BatchStreamMessage_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_weaviate_v1_BatchStreamMessage_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_descriptor, + new java.lang.String[] { "StreamId", "Error", "Start", "Stop", "Shutdown", "ShuttingDown", "Message", }); + internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor = + internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_BatchStreamMessage_Start_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_Start_descriptor, + new java.lang.String[] { }); + internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor = + internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(1); + internal_static_weaviate_v1_BatchStreamMessage_Stop_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_Stop_descriptor, + new java.lang.String[] { }); + internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor = + internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(2); + internal_static_weaviate_v1_BatchStreamMessage_Shutdown_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_Shutdown_descriptor, + new java.lang.String[] { }); + internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor = + internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(3); + internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_ShuttingDown_descriptor, + new java.lang.String[] { }); + internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor = + internal_static_weaviate_v1_BatchStreamMessage_descriptor.getNestedTypes().get(4); + internal_static_weaviate_v1_BatchStreamMessage_Error_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchStreamMessage_Error_descriptor, + new java.lang.String[] { "Error", "Index", "IsRetriable", "IsObject", "IsReference", }); + internal_static_weaviate_v1_BatchObject_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_weaviate_v1_BatchObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObject_descriptor, + new java.lang.String[] { "Uuid", "Vector", "Properties", "Collection", "Tenant", "VectorBytes", "Vectors", }); + internal_static_weaviate_v1_BatchObject_Properties_descriptor = + internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_BatchObject_Properties_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObject_Properties_descriptor, + new java.lang.String[] { "NonRefProperties", "SingleTargetRefProps", "MultiTargetRefProps", "NumberArrayProperties", "IntArrayProperties", "TextArrayProperties", "BooleanArrayProperties", "ObjectProperties", "ObjectArrayProperties", "EmptyListProps", }); + internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor = + internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(1); + internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObject_SingleTargetRefProps_descriptor, + new java.lang.String[] { "Uuids", "PropName", }); + internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor = + internal_static_weaviate_v1_BatchObject_descriptor.getNestedTypes().get(2); + internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObject_MultiTargetRefProps_descriptor, + new java.lang.String[] { "Uuids", "PropName", "TargetCollection", }); + internal_static_weaviate_v1_BatchReference_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_weaviate_v1_BatchReference_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchReference_descriptor, + new java.lang.String[] { "Name", "FromCollection", "FromUuid", "ToCollection", "ToUuid", "Tenant", "ToCollection", }); + internal_static_weaviate_v1_BatchObjectsReply_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_weaviate_v1_BatchObjectsReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObjectsReply_descriptor, + new java.lang.String[] { "Took", "Errors", }); + internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor = + internal_static_weaviate_v1_BatchObjectsReply_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_BatchObjectsReply_BatchError_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchObjectsReply_BatchError_descriptor, + new java.lang.String[] { "Index", "Error", }); + internal_static_weaviate_v1_BatchReferencesReply_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_weaviate_v1_BatchReferencesReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchReferencesReply_descriptor, + new java.lang.String[] { "Took", "Errors", }); + internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor = + internal_static_weaviate_v1_BatchReferencesReply_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_BatchReferencesReply_BatchError_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BatchReferencesReply_BatchError_descriptor, + new java.lang.String[] { "Index", "Error", }); + com.google.protobuf.StructProto.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatchDelete.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatchDelete.java similarity index 78% rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatchDelete.java rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatchDelete.java index 106c970d7..bf5fe8932 100644 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoBatchDelete.java +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoBatchDelete.java @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! // source: v1/batch_delete.proto -package io.weaviate.client.grpc.protocol.v1; +package io.weaviate.client6.v1.internal.grpc.protocol; public final class WeaviateProtoBatchDelete { private WeaviateProtoBatchDelete() {} @@ -39,11 +39,11 @@ public interface BatchDeleteRequestOrBuilder extends * .weaviate.v1.Filters filters = 2; * @return The filters. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(); /** * .weaviate.v1.Filters filters = 2; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(); /** * bool verbose = 3; @@ -71,7 +71,7 @@ public interface BatchDeleteRequestOrBuilder extends * optional .weaviate.v1.ConsistencyLevel consistency_level = 5; * @return The consistencyLevel. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); /** * optional string tenant = 6; @@ -117,15 +117,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.Builder.class); } private int bitField0_; @@ -169,7 +169,7 @@ public java.lang.String getCollection() { } public static final int FILTERS_FIELD_NUMBER = 2; - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_; /** * .weaviate.v1.Filters filters = 2; * @return Whether the filters field is set. @@ -183,15 +183,15 @@ public boolean hasFilters() { * @return The filters. */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() { + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; } /** * .weaviate.v1.Filters filters = 2; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; } public static final int VERBOSE_FIELD_NUMBER = 3; @@ -236,9 +236,9 @@ public boolean getDryRun() { * optional .weaviate.v1.ConsistencyLevel consistency_level = 5; * @return The consistencyLevel. */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; + @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; } public static final int TENANT_FIELD_NUMBER = 6; @@ -361,10 +361,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest) obj; if (!getCollection() .equals(other.getCollection())) return false; @@ -422,44 +422,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -467,26 +467,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -499,7 +499,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -520,21 +520,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchDeleteRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequestOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequestOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.newBuilder() private Builder() { maybeForceBuilderInitialization(); } @@ -570,17 +570,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteRequest_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -588,14 +588,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteR } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest(this); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.collection_ = collection_; @@ -658,16 +658,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest.getDefaultInstance()) return this; if (!other.getCollection().isEmpty()) { collection_ = other.collection_; bitField0_ |= 0x00000001; @@ -837,9 +837,9 @@ public Builder setCollectionBytes( return this; } - private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters filters_; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_; private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_; /** * .weaviate.v1.Filters filters = 2; * @return Whether the filters field is set. @@ -851,9 +851,9 @@ public boolean hasFilters() { * .weaviate.v1.Filters filters = 2; * @return The filters. */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() { if (filtersBuilder_ == null) { - return filters_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; } else { return filtersBuilder_.getMessage(); } @@ -861,7 +861,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters getFilters( /** * .weaviate.v1.Filters filters = 2; */ - public Builder setFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) { + public Builder setFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) { if (filtersBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -878,7 +878,7 @@ public Builder setFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase. * .weaviate.v1.Filters filters = 2; */ public Builder setFilters( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder builderForValue) { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) { if (filtersBuilder_ == null) { filters_ = builderForValue.build(); } else { @@ -891,11 +891,11 @@ public Builder setFilters( /** * .weaviate.v1.Filters filters = 2; */ - public Builder mergeFilters(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters value) { + public Builder mergeFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) { if (filtersBuilder_ == null) { if (((bitField0_ & 0x00000002) != 0) && filters_ != null && - filters_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance()) { + filters_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance()) { getFiltersBuilder().mergeFrom(value); } else { filters_ = value; @@ -925,7 +925,7 @@ public Builder clearFilters() { /** * .weaviate.v1.Filters filters = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder getFiltersBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder getFiltersBuilder() { bitField0_ |= 0x00000002; onChanged(); return getFiltersFieldBuilder().getBuilder(); @@ -933,23 +933,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder get /** * .weaviate.v1.Filters filters = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { if (filtersBuilder_ != null) { return filtersBuilder_.getMessageOrBuilder(); } else { return filters_ == null ? - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; } } /** * .weaviate.v1.Filters filters = 2; */ private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder> + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> getFiltersFieldBuilder() { if (filtersBuilder_ == null) { filtersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Filters.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.FiltersOrBuilder>( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder>( getFilters(), getParentForChildren(), isClean()); @@ -1053,16 +1053,16 @@ public Builder setConsistencyLevelValue(int value) { * @return The consistencyLevel. */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; } /** * optional .weaviate.v1.ConsistencyLevel consistency_level = 5; * @param value The consistencyLevel to set. * @return This builder for chaining. */ - public Builder setConsistencyLevel(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.ConsistencyLevel value) { + public Builder setConsistencyLevel(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel value) { if (value == null) { throw new NullPointerException(); } @@ -1177,12 +1177,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.BatchDeleteRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -1218,7 +1218,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteRequest getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -1255,12 +1255,12 @@ public interface BatchDeleteReplyOrBuilder extends /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - java.util.List + java.util.List getObjectsList(); /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index); /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ @@ -1268,12 +1268,12 @@ public interface BatchDeleteReplyOrBuilder extends /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - java.util.List + java.util.List getObjectsOrBuilderList(); /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( int index); } /** @@ -1301,15 +1301,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.Builder.class); } public static final int TOOK_FIELD_NUMBER = 1; @@ -1358,19 +1358,19 @@ public long getSuccessful() { public static final int OBJECTS_FIELD_NUMBER = 5; @SuppressWarnings("serial") - private java.util.List objects_; + private java.util.List objects_; /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ @java.lang.Override - public java.util.List getObjectsList() { + public java.util.List getObjectsList() { return objects_; } /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ @java.lang.Override - public java.util.List + public java.util.List getObjectsOrBuilderList() { return objects_; } @@ -1385,14 +1385,14 @@ public int getObjectsCount() { * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index) { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index) { return objects_.get(index); } /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( int index) { return objects_.get(index); } @@ -1465,10 +1465,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply) obj; if (java.lang.Float.floatToIntBits(getTook()) != java.lang.Float.floatToIntBits( @@ -1513,44 +1513,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1558,26 +1558,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1590,7 +1590,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -1611,21 +1611,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchDeleteReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReplyOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReplyOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.newBuilder() private Builder() { } @@ -1656,17 +1656,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteReply_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -1674,15 +1674,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteR } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply(this); buildPartialRepeatedFields(result); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply result) { + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply result) { if (objectsBuilder_ == null) { if (((bitField0_ & 0x00000010) != 0)) { objects_ = java.util.Collections.unmodifiableList(objects_); @@ -1694,7 +1694,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav } } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.took_ = took_; @@ -1744,16 +1744,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply.getDefaultInstance()) return this; if (other.getTook() != 0F) { setTook(other.getTook()); } @@ -1839,9 +1839,9 @@ public Builder mergeFrom( break; } // case 32 case 42: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject m = + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject m = input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.parser(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.parser(), extensionRegistry); if (objectsBuilder_ == null) { ensureObjectsIsMutable(); @@ -1996,22 +1996,22 @@ public Builder clearSuccessful() { return this; } - private java.util.List objects_ = + private java.util.List objects_ = java.util.Collections.emptyList(); private void ensureObjectsIsMutable() { if (!((bitField0_ & 0x00000010) != 0)) { - objects_ = new java.util.ArrayList(objects_); + objects_ = new java.util.ArrayList(objects_); bitField0_ |= 0x00000010; } } private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder> objectsBuilder_; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder> objectsBuilder_; /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public java.util.List getObjectsList() { + public java.util.List getObjectsList() { if (objectsBuilder_ == null) { return java.util.Collections.unmodifiableList(objects_); } else { @@ -2031,7 +2031,7 @@ public int getObjectsCount() { /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index) { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getObjects(int index) { if (objectsBuilder_ == null) { return objects_.get(index); } else { @@ -2042,7 +2042,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject value) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject value) { if (objectsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2059,7 +2059,7 @@ public Builder setObjects( * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder setObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { if (objectsBuilder_ == null) { ensureObjectsIsMutable(); objects_.set(index, builderForValue.build()); @@ -2072,7 +2072,7 @@ public Builder setObjects( /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public Builder addObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject value) { + public Builder addObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject value) { if (objectsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2089,7 +2089,7 @@ public Builder addObjects(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject value) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject value) { if (objectsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2106,7 +2106,7 @@ public Builder addObjects( * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder addObjects( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { if (objectsBuilder_ == null) { ensureObjectsIsMutable(); objects_.add(builderForValue.build()); @@ -2120,7 +2120,7 @@ public Builder addObjects( * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder addObjects( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder builderForValue) { if (objectsBuilder_ == null) { ensureObjectsIsMutable(); objects_.add(index, builderForValue.build()); @@ -2134,7 +2134,7 @@ public Builder addObjects( * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ public Builder addAllObjects( - java.lang.Iterable values) { + java.lang.Iterable values) { if (objectsBuilder_ == null) { ensureObjectsIsMutable(); com.google.protobuf.AbstractMessageLite.Builder.addAll( @@ -2174,14 +2174,14 @@ public Builder removeObjects(int index) { /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder getObjectsBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder getObjectsBuilder( int index) { return getObjectsFieldBuilder().getBuilder(index); } /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder getObjectsOrBuilder( int index) { if (objectsBuilder_ == null) { return objects_.get(index); } else { @@ -2191,7 +2191,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public java.util.List + public java.util.List getObjectsOrBuilderList() { if (objectsBuilder_ != null) { return objectsBuilder_.getMessageOrBuilderList(); @@ -2202,31 +2202,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder addObjectsBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder addObjectsBuilder() { return getObjectsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()); } /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder addObjectsBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder addObjectsBuilder( int index) { return getObjectsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()); + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()); } /** * repeated .weaviate.v1.BatchDeleteObject objects = 5; */ - public java.util.List + public java.util.List getObjectsBuilderList() { return getObjectsFieldBuilder().getBuilderList(); } private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder> + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder> getObjectsFieldBuilder() { if (objectsBuilder_ == null) { objectsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder>( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder>( objects_, ((bitField0_ & 0x00000010) != 0), getParentForChildren(), @@ -2252,12 +2252,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.BatchDeleteReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -2293,7 +2293,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteReply getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -2370,15 +2370,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder.class); } private int bitField0_; @@ -2516,10 +2516,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject) obj; if (!getUuid() .equals(other.getUuid())) return false; @@ -2555,44 +2555,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -2600,26 +2600,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -2632,7 +2632,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.Batch public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -2653,21 +2653,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.BatchDeleteObject) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObjectOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.newBuilder() private Builder() { } @@ -2690,17 +2690,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.internal_static_weaviate_v1_BatchDeleteObject_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -2708,14 +2708,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject(this); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.uuid_ = uuid_; @@ -2765,16 +2765,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject.getDefaultInstance()) return this; if (other.getUuid() != com.google.protobuf.ByteString.EMPTY) { setUuid(other.getUuid()); } @@ -3027,12 +3027,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.BatchDeleteObject) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -3068,7 +3068,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete.BatchDeleteObject getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -3110,15 +3110,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO "essful\030\004 \001(\003\022/\n\007objects\030\005 \003(\0132\036.weaviate" + ".v1.BatchDeleteObject\"S\n\021BatchDeleteObje" + "ct\022\014\n\004uuid\030\001 \001(\014\022\022\n\nsuccessful\030\002 \001(\010\022\022\n\005" + - "error\030\003 \001(\tH\000\210\001\001B\010\n\006_errorBu\n#io.weaviat" + - "e.client.grpc.protocol.v1B\030WeaviateProto" + - "BatchDeleteZ4github.com/weaviate/weaviat" + - "e/grpc/generated;protocolb\006proto3" + "error\030\003 \001(\tH\000\210\001\001B\010\n\006_errorBI\n-io.weaviat" + + "e.client6.v1.internal.grpc.protocolB\030Wea" + + "viateProtoBatchDeleteb\006proto3" }; descriptor = com.google.protobuf.Descriptors.FileDescriptor .internalBuildGeneratedFileFrom(descriptorData, new com.google.protobuf.Descriptors.FileDescriptor[] { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(), }); internal_static_weaviate_v1_BatchDeleteRequest_descriptor = getDescriptor().getMessageTypes().get(0); @@ -3138,7 +3137,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatchDelete.BatchDeleteO com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( internal_static_weaviate_v1_BatchDeleteObject_descriptor, new java.lang.String[] { "Uuid", "Successful", "Error", "Error", }); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(); } // @@protoc_insertion_point(outer_class_scope) diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoFileReplication.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoFileReplication.java new file mode 100644 index 000000000..6805d6201 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoFileReplication.java @@ -0,0 +1,8341 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: v1/file_replication.proto + +package io.weaviate.client6.v1.internal.grpc.protocol; + +public final class WeaviateProtoFileReplication { + private WeaviateProtoFileReplication() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + /** + * Protobuf enum {@code weaviate.v1.CompressionType} + */ + public enum CompressionType + implements com.google.protobuf.ProtocolMessageEnum { + /** + *
+     * No compression
+     * 
+ * + * COMPRESSION_TYPE_UNSPECIFIED = 0; + */ + COMPRESSION_TYPE_UNSPECIFIED(0), + /** + *
+     * gzip (compress/gzip)
+     * 
+ * + * COMPRESSION_TYPE_GZIP = 1; + */ + COMPRESSION_TYPE_GZIP(1), + /** + *
+     * zlib (compress/zlib)
+     * 
+ * + * COMPRESSION_TYPE_ZLIB = 2; + */ + COMPRESSION_TYPE_ZLIB(2), + /** + *
+     * raw DEFLATE (compress/flate)
+     * 
+ * + * COMPRESSION_TYPE_DEFLATE = 3; + */ + COMPRESSION_TYPE_DEFLATE(3), + UNRECOGNIZED(-1), + ; + + /** + *
+     * No compression
+     * 
+ * + * COMPRESSION_TYPE_UNSPECIFIED = 0; + */ + public static final int COMPRESSION_TYPE_UNSPECIFIED_VALUE = 0; + /** + *
+     * gzip (compress/gzip)
+     * 
+ * + * COMPRESSION_TYPE_GZIP = 1; + */ + public static final int COMPRESSION_TYPE_GZIP_VALUE = 1; + /** + *
+     * zlib (compress/zlib)
+     * 
+ * + * COMPRESSION_TYPE_ZLIB = 2; + */ + public static final int COMPRESSION_TYPE_ZLIB_VALUE = 2; + /** + *
+     * raw DEFLATE (compress/flate)
+     * 
+ * + * COMPRESSION_TYPE_DEFLATE = 3; + */ + public static final int COMPRESSION_TYPE_DEFLATE_VALUE = 3; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static CompressionType valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static CompressionType forNumber(int value) { + switch (value) { + case 0: return COMPRESSION_TYPE_UNSPECIFIED; + case 1: return COMPRESSION_TYPE_GZIP; + case 2: return COMPRESSION_TYPE_ZLIB; + case 3: return COMPRESSION_TYPE_DEFLATE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + CompressionType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public CompressionType findValueByNumber(int number) { + return CompressionType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalStateException( + "Can't get the descriptor of an unrecognized enum value."); + } + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.getDescriptor().getEnumTypes().get(0); + } + + private static final CompressionType[] VALUES = values(); + + public static CompressionType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private CompressionType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:weaviate.v1.CompressionType) + } + + public interface PauseFileActivityRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + + /** + * uint64 schema_version = 3; + * @return The schemaVersion. + */ + long getSchemaVersion(); + } + /** + * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} + */ + public static final class PauseFileActivityRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityRequest) + PauseFileActivityRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use PauseFileActivityRequest.newBuilder() to construct. + private PauseFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private PauseFileActivityRequest() { + indexName_ = ""; + shardName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new PauseFileActivityRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SCHEMA_VERSION_FIELD_NUMBER = 3; + private long schemaVersion_ = 0L; + /** + * uint64 schema_version = 3; + * @return The schemaVersion. + */ + @java.lang.Override + public long getSchemaVersion() { + return schemaVersion_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + if (schemaVersion_ != 0L) { + output.writeUInt64(3, schemaVersion_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + if (schemaVersion_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(3, schemaVersion_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (getSchemaVersion() + != other.getSchemaVersion()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (37 * hash) + SCHEMA_VERSION_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getSchemaVersion()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.PauseFileActivityRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + schemaVersion_ = 0L; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.schemaVersion_ = schemaVersion_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (other.getSchemaVersion() != 0L) { + setSchemaVersion(other.getSchemaVersion()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 24: { + schemaVersion_ = input.readUInt64(); + bitField0_ |= 0x00000004; + break; + } // case 24 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private long schemaVersion_ ; + /** + * uint64 schema_version = 3; + * @return The schemaVersion. + */ + @java.lang.Override + public long getSchemaVersion() { + return schemaVersion_; + } + /** + * uint64 schema_version = 3; + * @param value The schemaVersion to set. + * @return This builder for chaining. + */ + public Builder setSchemaVersion(long value) { + + schemaVersion_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * uint64 schema_version = 3; + * @return This builder for chaining. + */ + public Builder clearSchemaVersion() { + bitField0_ = (bitField0_ & ~0x00000004); + schemaVersion_ = 0L; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public PauseFileActivityRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface PauseFileActivityResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.PauseFileActivityResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} + */ + public static final class PauseFileActivityResponse extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.PauseFileActivityResponse) + PauseFileActivityResponseOrBuilder { + private static final long serialVersionUID = 0L; + // Use PauseFileActivityResponse.newBuilder() to construct. + private PauseFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private PauseFileActivityResponse() { + indexName_ = ""; + shardName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new PauseFileActivityResponse(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.PauseFileActivityResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.PauseFileActivityResponse) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.PauseFileActivityResponse) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.PauseFileActivityResponse) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public PauseFileActivityResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.PauseFileActivityResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ResumeFileActivityRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} + */ + public static final class ResumeFileActivityRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityRequest) + ResumeFileActivityRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use ResumeFileActivityRequest.newBuilder() to construct. + private ResumeFileActivityRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ResumeFileActivityRequest() { + indexName_ = ""; + shardName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ResumeFileActivityRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ResumeFileActivityRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ResumeFileActivityRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ResumeFileActivityResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ResumeFileActivityResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} + */ + public static final class ResumeFileActivityResponse extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ResumeFileActivityResponse) + ResumeFileActivityResponseOrBuilder { + private static final long serialVersionUID = 0L; + // Use ResumeFileActivityResponse.newBuilder() to construct. + private ResumeFileActivityResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ResumeFileActivityResponse() { + indexName_ = ""; + shardName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ResumeFileActivityResponse(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ResumeFileActivityResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ResumeFileActivityResponse) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ResumeFileActivityResponse) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ResumeFileActivityResponse) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ResumeFileActivityResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ResumeFileActivityResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ListFilesRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.ListFilesRequest} + */ + public static final class ListFilesRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesRequest) + ListFilesRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use ListFilesRequest.newBuilder() to construct. + private ListFilesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ListFilesRequest() { + indexName_ = ""; + shardName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ListFilesRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ListFilesRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ListFilesRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ListFilesResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ListFilesResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + + /** + * repeated string file_names = 3; + * @return A list containing the fileNames. + */ + java.util.List + getFileNamesList(); + /** + * repeated string file_names = 3; + * @return The count of fileNames. + */ + int getFileNamesCount(); + /** + * repeated string file_names = 3; + * @param index The index of the element to return. + * @return The fileNames at the given index. + */ + java.lang.String getFileNames(int index); + /** + * repeated string file_names = 3; + * @param index The index of the value to return. + * @return The bytes of the fileNames at the given index. + */ + com.google.protobuf.ByteString + getFileNamesBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.ListFilesResponse} + */ + public static final class ListFilesResponse extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ListFilesResponse) + ListFilesResponseOrBuilder { + private static final long serialVersionUID = 0L; + // Use ListFilesResponse.newBuilder() to construct. + private ListFilesResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ListFilesResponse() { + indexName_ = ""; + shardName_ = ""; + fileNames_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ListFilesResponse(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FILE_NAMES_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList fileNames_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string file_names = 3; + * @return A list containing the fileNames. + */ + public com.google.protobuf.ProtocolStringList + getFileNamesList() { + return fileNames_; + } + /** + * repeated string file_names = 3; + * @return The count of fileNames. + */ + public int getFileNamesCount() { + return fileNames_.size(); + } + /** + * repeated string file_names = 3; + * @param index The index of the element to return. + * @return The fileNames at the given index. + */ + public java.lang.String getFileNames(int index) { + return fileNames_.get(index); + } + /** + * repeated string file_names = 3; + * @param index The index of the value to return. + * @return The bytes of the fileNames at the given index. + */ + public com.google.protobuf.ByteString + getFileNamesBytes(int index) { + return fileNames_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + for (int i = 0; i < fileNames_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileNames_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + { + int dataSize = 0; + for (int i = 0; i < fileNames_.size(); i++) { + dataSize += computeStringSizeNoTag(fileNames_.getRaw(i)); + } + size += dataSize; + size += 1 * getFileNamesList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getFileNamesList() + .equals(other.getFileNamesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + if (getFileNamesCount() > 0) { + hash = (37 * hash) + FILE_NAMES_FIELD_NUMBER; + hash = (53 * hash) + getFileNamesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ListFilesResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ListFilesResponse) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesResponse_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + fileNames_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_ListFilesResponse_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + fileNames_.makeImmutable(); + result.fileNames_ = fileNames_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.fileNames_.isEmpty()) { + if (fileNames_.isEmpty()) { + fileNames_ = other.fileNames_; + bitField0_ |= 0x00000004; + } else { + ensureFileNamesIsMutable(); + fileNames_.addAll(other.fileNames_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + java.lang.String s = input.readStringRequireUtf8(); + ensureFileNamesIsMutable(); + fileNames_.add(s); + break; + } // case 26 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringArrayList fileNames_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureFileNamesIsMutable() { + if (!fileNames_.isModifiable()) { + fileNames_ = new com.google.protobuf.LazyStringArrayList(fileNames_); + } + bitField0_ |= 0x00000004; + } + /** + * repeated string file_names = 3; + * @return A list containing the fileNames. + */ + public com.google.protobuf.ProtocolStringList + getFileNamesList() { + fileNames_.makeImmutable(); + return fileNames_; + } + /** + * repeated string file_names = 3; + * @return The count of fileNames. + */ + public int getFileNamesCount() { + return fileNames_.size(); + } + /** + * repeated string file_names = 3; + * @param index The index of the element to return. + * @return The fileNames at the given index. + */ + public java.lang.String getFileNames(int index) { + return fileNames_.get(index); + } + /** + * repeated string file_names = 3; + * @param index The index of the value to return. + * @return The bytes of the fileNames at the given index. + */ + public com.google.protobuf.ByteString + getFileNamesBytes(int index) { + return fileNames_.getByteString(index); + } + /** + * repeated string file_names = 3; + * @param index The index to set the value at. + * @param value The fileNames to set. + * @return This builder for chaining. + */ + public Builder setFileNames( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureFileNamesIsMutable(); + fileNames_.set(index, value); + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * repeated string file_names = 3; + * @param value The fileNames to add. + * @return This builder for chaining. + */ + public Builder addFileNames( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureFileNamesIsMutable(); + fileNames_.add(value); + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * repeated string file_names = 3; + * @param values The fileNames to add. + * @return This builder for chaining. + */ + public Builder addAllFileNames( + java.lang.Iterable values) { + ensureFileNamesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, fileNames_); + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * repeated string file_names = 3; + * @return This builder for chaining. + */ + public Builder clearFileNames() { + fileNames_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004);; + onChanged(); + return this; + } + /** + * repeated string file_names = 3; + * @param value The bytes of the fileNames to add. + * @return This builder for chaining. + */ + public Builder addFileNamesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureFileNamesIsMutable(); + fileNames_.add(value); + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ListFilesResponse) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ListFilesResponse) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ListFilesResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.ListFilesResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GetFileMetadataRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileMetadataRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + + /** + * string file_name = 3; + * @return The fileName. + */ + java.lang.String getFileName(); + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + com.google.protobuf.ByteString + getFileNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} + */ + public static final class GetFileMetadataRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileMetadataRequest) + GetFileMetadataRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use GetFileMetadataRequest.newBuilder() to construct. + private GetFileMetadataRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GetFileMetadataRequest() { + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GetFileMetadataRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FILE_NAME_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + @java.lang.Override + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getFileName() + .equals(other.getFileName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; + hash = (53 * hash) + getFileName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.GetFileMetadataRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileMetadataRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.fileName_ = fileName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getFileName().isEmpty()) { + fileName_ = other.fileName_; + bitField0_ |= 0x00000004; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + fileName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string file_name = 3; + * @param value The fileName to set. + * @return This builder for chaining. + */ + public Builder setFileName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string file_name = 3; + * @return This builder for chaining. + */ + public Builder clearFileName() { + fileName_ = getDefaultInstance().getFileName(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string file_name = 3; + * @param value The bytes for fileName to set. + * @return This builder for chaining. + */ + public Builder setFileNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileMetadataRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileMetadataRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GetFileMetadataRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileMetadataRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FileMetadataOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.FileMetadata) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + + /** + * string file_name = 3; + * @return The fileName. + */ + java.lang.String getFileName(); + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + com.google.protobuf.ByteString + getFileNameBytes(); + + /** + * int64 size = 4; + * @return The size. + */ + long getSize(); + + /** + * uint32 crc32 = 5; + * @return The crc32. + */ + int getCrc32(); + } + /** + * Protobuf type {@code weaviate.v1.FileMetadata} + */ + public static final class FileMetadata extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.FileMetadata) + FileMetadataOrBuilder { + private static final long serialVersionUID = 0L; + // Use FileMetadata.newBuilder() to construct. + private FileMetadata(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FileMetadata() { + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FileMetadata(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileMetadata_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FILE_NAME_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + @java.lang.Override + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SIZE_FIELD_NUMBER = 4; + private long size_ = 0L; + /** + * int64 size = 4; + * @return The size. + */ + @java.lang.Override + public long getSize() { + return size_; + } + + public static final int CRC32_FIELD_NUMBER = 5; + private int crc32_ = 0; + /** + * uint32 crc32 = 5; + * @return The crc32. + */ + @java.lang.Override + public int getCrc32() { + return crc32_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); + } + if (size_ != 0L) { + output.writeInt64(4, size_); + } + if (crc32_ != 0) { + output.writeUInt32(5, crc32_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); + } + if (size_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(4, size_); + } + if (crc32_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(5, crc32_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getFileName() + .equals(other.getFileName())) return false; + if (getSize() + != other.getSize()) return false; + if (getCrc32() + != other.getCrc32()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; + hash = (53 * hash) + getFileName().hashCode(); + hash = (37 * hash) + SIZE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getSize()); + hash = (37 * hash) + CRC32_FIELD_NUMBER; + hash = (53 * hash) + getCrc32(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.FileMetadata} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.FileMetadata) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileMetadata_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileMetadata_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + size_ = 0L; + crc32_ = 0; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileMetadata_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.fileName_ = fileName_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.size_ = size_; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.crc32_ = crc32_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getFileName().isEmpty()) { + fileName_ = other.fileName_; + bitField0_ |= 0x00000004; + onChanged(); + } + if (other.getSize() != 0L) { + setSize(other.getSize()); + } + if (other.getCrc32() != 0) { + setCrc32(other.getCrc32()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + fileName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 32: { + size_ = input.readInt64(); + bitField0_ |= 0x00000008; + break; + } // case 32 + case 40: { + crc32_ = input.readUInt32(); + bitField0_ |= 0x00000010; + break; + } // case 40 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string file_name = 3; + * @param value The fileName to set. + * @return This builder for chaining. + */ + public Builder setFileName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string file_name = 3; + * @return This builder for chaining. + */ + public Builder clearFileName() { + fileName_ = getDefaultInstance().getFileName(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string file_name = 3; + * @param value The bytes for fileName to set. + * @return This builder for chaining. + */ + public Builder setFileNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + + private long size_ ; + /** + * int64 size = 4; + * @return The size. + */ + @java.lang.Override + public long getSize() { + return size_; + } + /** + * int64 size = 4; + * @param value The size to set. + * @return This builder for chaining. + */ + public Builder setSize(long value) { + + size_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * int64 size = 4; + * @return This builder for chaining. + */ + public Builder clearSize() { + bitField0_ = (bitField0_ & ~0x00000008); + size_ = 0L; + onChanged(); + return this; + } + + private int crc32_ ; + /** + * uint32 crc32 = 5; + * @return The crc32. + */ + @java.lang.Override + public int getCrc32() { + return crc32_; + } + /** + * uint32 crc32 = 5; + * @param value The crc32 to set. + * @return This builder for chaining. + */ + public Builder setCrc32(int value) { + + crc32_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * uint32 crc32 = 5; + * @return This builder for chaining. + */ + public Builder clearCrc32() { + bitField0_ = (bitField0_ & ~0x00000010); + crc32_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.FileMetadata) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.FileMetadata) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FileMetadata parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileMetadata getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GetFileRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.GetFileRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string index_name = 1; + * @return The indexName. + */ + java.lang.String getIndexName(); + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + com.google.protobuf.ByteString + getIndexNameBytes(); + + /** + * string shard_name = 2; + * @return The shardName. + */ + java.lang.String getShardName(); + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + com.google.protobuf.ByteString + getShardNameBytes(); + + /** + * string file_name = 3; + * @return The fileName. + */ + java.lang.String getFileName(); + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + com.google.protobuf.ByteString + getFileNameBytes(); + + /** + *
+     * Requested compression algorithm for streamed chunks
+     * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The enum numeric value on the wire for compression. + */ + int getCompressionValue(); + /** + *
+     * Requested compression algorithm for streamed chunks
+     * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The compression. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType getCompression(); + } + /** + * Protobuf type {@code weaviate.v1.GetFileRequest} + */ + public static final class GetFileRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.GetFileRequest) + GetFileRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use GetFileRequest.newBuilder() to construct. + private GetFileRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GetFileRequest() { + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + compression_ = 0; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GetFileRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.Builder.class); + } + + public static final int INDEX_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + @java.lang.Override + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SHARD_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + @java.lang.Override + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int FILE_NAME_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + @java.lang.Override + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int COMPRESSION_FIELD_NUMBER = 4; + private int compression_ = 0; + /** + *
+     * Requested compression algorithm for streamed chunks
+     * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The enum numeric value on the wire for compression. + */ + @java.lang.Override public int getCompressionValue() { + return compression_; + } + /** + *
+     * Requested compression algorithm for streamed chunks
+     * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The compression. + */ + @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType getCompression() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.forNumber(compression_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.UNRECOGNIZED : result; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, fileName_); + } + if (compression_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { + output.writeEnum(4, compression_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(indexName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, indexName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(shardName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, shardName_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(fileName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, fileName_); + } + if (compression_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.COMPRESSION_TYPE_UNSPECIFIED.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(4, compression_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest) obj; + + if (!getIndexName() + .equals(other.getIndexName())) return false; + if (!getShardName() + .equals(other.getShardName())) return false; + if (!getFileName() + .equals(other.getFileName())) return false; + if (compression_ != other.compression_) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + INDEX_NAME_FIELD_NUMBER; + hash = (53 * hash) + getIndexName().hashCode(); + hash = (37 * hash) + SHARD_NAME_FIELD_NUMBER; + hash = (53 * hash) + getShardName().hashCode(); + hash = (37 * hash) + FILE_NAME_FIELD_NUMBER; + hash = (53 * hash) + getFileName().hashCode(); + hash = (37 * hash) + COMPRESSION_FIELD_NUMBER; + hash = (53 * hash) + compression_; + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.GetFileRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.GetFileRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + indexName_ = ""; + shardName_ = ""; + fileName_ = ""; + compression_ = 0; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_GetFileRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.indexName_ = indexName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.shardName_ = shardName_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.fileName_ = fileName_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.compression_ = compression_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest.getDefaultInstance()) return this; + if (!other.getIndexName().isEmpty()) { + indexName_ = other.indexName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getShardName().isEmpty()) { + shardName_ = other.shardName_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getFileName().isEmpty()) { + fileName_ = other.fileName_; + bitField0_ |= 0x00000004; + onChanged(); + } + if (other.compression_ != 0) { + setCompressionValue(other.getCompressionValue()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + indexName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + shardName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + fileName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 32: { + compression_ = input.readEnum(); + bitField0_ |= 0x00000008; + break; + } // case 32 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object indexName_ = ""; + /** + * string index_name = 1; + * @return The indexName. + */ + public java.lang.String getIndexName() { + java.lang.Object ref = indexName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + indexName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string index_name = 1; + * @return The bytes for indexName. + */ + public com.google.protobuf.ByteString + getIndexNameBytes() { + java.lang.Object ref = indexName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + indexName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string index_name = 1; + * @param value The indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string index_name = 1; + * @return This builder for chaining. + */ + public Builder clearIndexName() { + indexName_ = getDefaultInstance().getIndexName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string index_name = 1; + * @param value The bytes for indexName to set. + * @return This builder for chaining. + */ + public Builder setIndexNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + indexName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object shardName_ = ""; + /** + * string shard_name = 2; + * @return The shardName. + */ + public java.lang.String getShardName() { + java.lang.Object ref = shardName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + shardName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string shard_name = 2; + * @return The bytes for shardName. + */ + public com.google.protobuf.ByteString + getShardNameBytes() { + java.lang.Object ref = shardName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + shardName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string shard_name = 2; + * @param value The shardName to set. + * @return This builder for chaining. + */ + public Builder setShardName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @return This builder for chaining. + */ + public Builder clearShardName() { + shardName_ = getDefaultInstance().getShardName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string shard_name = 2; + * @param value The bytes for shardName to set. + * @return This builder for chaining. + */ + public Builder setShardNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + shardName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object fileName_ = ""; + /** + * string file_name = 3; + * @return The fileName. + */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + fileName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string file_name = 3; + * @return The bytes for fileName. + */ + public com.google.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string file_name = 3; + * @param value The fileName to set. + * @return This builder for chaining. + */ + public Builder setFileName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string file_name = 3; + * @return This builder for chaining. + */ + public Builder clearFileName() { + fileName_ = getDefaultInstance().getFileName(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string file_name = 3; + * @param value The bytes for fileName to set. + * @return This builder for chaining. + */ + public Builder setFileNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + fileName_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + + private int compression_ = 0; + /** + *
+       * Requested compression algorithm for streamed chunks
+       * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The enum numeric value on the wire for compression. + */ + @java.lang.Override public int getCompressionValue() { + return compression_; + } + /** + *
+       * Requested compression algorithm for streamed chunks
+       * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @param value The enum numeric value on the wire for compression to set. + * @return This builder for chaining. + */ + public Builder setCompressionValue(int value) { + compression_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + *
+       * Requested compression algorithm for streamed chunks
+       * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return The compression. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType getCompression() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.forNumber(compression_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType.UNRECOGNIZED : result; + } + /** + *
+       * Requested compression algorithm for streamed chunks
+       * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @param value The compression to set. + * @return This builder for chaining. + */ + public Builder setCompression(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.CompressionType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + compression_ = value.getNumber(); + onChanged(); + return this; + } + /** + *
+       * Requested compression algorithm for streamed chunks
+       * 
+ * + * .weaviate.v1.CompressionType compression = 4; + * @return This builder for chaining. + */ + public Builder clearCompression() { + bitField0_ = (bitField0_ & ~0x00000008); + compression_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.GetFileRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.GetFileRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GetFileRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.GetFileRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FileChunkOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.FileChunk) + com.google.protobuf.MessageOrBuilder { + + /** + *
+     * Byte offset in the uncompressed file
+     * 
+ * + * int64 offset = 1; + * @return The offset. + */ + long getOffset(); + + /** + *
+     * Compressed or raw chunk data
+     * 
+ * + * bytes data = 2; + * @return The data. + */ + com.google.protobuf.ByteString getData(); + + /** + *
+     * Indicates final chunk
+     * 
+ * + * bool eof = 3; + * @return The eof. + */ + boolean getEof(); + } + /** + * Protobuf type {@code weaviate.v1.FileChunk} + */ + public static final class FileChunk extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.FileChunk) + FileChunkOrBuilder { + private static final long serialVersionUID = 0L; + // Use FileChunk.newBuilder() to construct. + private FileChunk(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FileChunk() { + data_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FileChunk(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileChunk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileChunk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.Builder.class); + } + + public static final int OFFSET_FIELD_NUMBER = 1; + private long offset_ = 0L; + /** + *
+     * Byte offset in the uncompressed file
+     * 
+ * + * int64 offset = 1; + * @return The offset. + */ + @java.lang.Override + public long getOffset() { + return offset_; + } + + public static final int DATA_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+     * Compressed or raw chunk data
+     * 
+ * + * bytes data = 2; + * @return The data. + */ + @java.lang.Override + public com.google.protobuf.ByteString getData() { + return data_; + } + + public static final int EOF_FIELD_NUMBER = 3; + private boolean eof_ = false; + /** + *
+     * Indicates final chunk
+     * 
+ * + * bool eof = 3; + * @return The eof. + */ + @java.lang.Override + public boolean getEof() { + return eof_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (offset_ != 0L) { + output.writeInt64(1, offset_); + } + if (!data_.isEmpty()) { + output.writeBytes(2, data_); + } + if (eof_ != false) { + output.writeBool(3, eof_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (offset_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(1, offset_); + } + if (!data_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, data_); + } + if (eof_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, eof_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk) obj; + + if (getOffset() + != other.getOffset()) return false; + if (!getData() + .equals(other.getData())) return false; + if (getEof() + != other.getEof()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + OFFSET_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getOffset()); + hash = (37 * hash) + DATA_FIELD_NUMBER; + hash = (53 * hash) + getData().hashCode(); + hash = (37 * hash) + EOF_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getEof()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.FileChunk} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.FileChunk) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileChunk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileChunk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + offset_ = 0L; + data_ = com.google.protobuf.ByteString.EMPTY; + eof_ = false; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.internal_static_weaviate_v1_FileChunk_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.offset_ = offset_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.data_ = data_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.eof_ = eof_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk.getDefaultInstance()) return this; + if (other.getOffset() != 0L) { + setOffset(other.getOffset()); + } + if (other.getData() != com.google.protobuf.ByteString.EMPTY) { + setData(other.getData()); + } + if (other.getEof() != false) { + setEof(other.getEof()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + offset_ = input.readInt64(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 18: { + data_ = input.readBytes(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 24: { + eof_ = input.readBool(); + bitField0_ |= 0x00000004; + break; + } // case 24 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private long offset_ ; + /** + *
+       * Byte offset in the uncompressed file
+       * 
+ * + * int64 offset = 1; + * @return The offset. + */ + @java.lang.Override + public long getOffset() { + return offset_; + } + /** + *
+       * Byte offset in the uncompressed file
+       * 
+ * + * int64 offset = 1; + * @param value The offset to set. + * @return This builder for chaining. + */ + public Builder setOffset(long value) { + + offset_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       * Byte offset in the uncompressed file
+       * 
+ * + * int64 offset = 1; + * @return This builder for chaining. + */ + public Builder clearOffset() { + bitField0_ = (bitField0_ & ~0x00000001); + offset_ = 0L; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+       * Compressed or raw chunk data
+       * 
+ * + * bytes data = 2; + * @return The data. + */ + @java.lang.Override + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + *
+       * Compressed or raw chunk data
+       * 
+ * + * bytes data = 2; + * @param value The data to set. + * @return This builder for chaining. + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + data_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * Compressed or raw chunk data
+       * 
+ * + * bytes data = 2; + * @return This builder for chaining. + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000002); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + private boolean eof_ ; + /** + *
+       * Indicates final chunk
+       * 
+ * + * bool eof = 3; + * @return The eof. + */ + @java.lang.Override + public boolean getEof() { + return eof_; + } + /** + *
+       * Indicates final chunk
+       * 
+ * + * bool eof = 3; + * @param value The eof to set. + * @return This builder for chaining. + */ + public Builder setEof(boolean value) { + + eof_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + *
+       * Indicates final chunk
+       * 
+ * + * bool eof = 3; + * @return This builder for chaining. + */ + public Builder clearEof() { + bitField0_ = (bitField0_ & ~0x00000004); + eof_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.FileChunk) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.FileChunk) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FileChunk parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoFileReplication.FileChunk getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_PauseFileActivityRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_PauseFileActivityResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ListFilesRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ListFilesResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_GetFileMetadataRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_FileMetadata_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_FileMetadata_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_GetFileRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_FileChunk_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_FileChunk_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\031v1/file_replication.proto\022\013weaviate.v1" + + "\"Z\n\030PauseFileActivityRequest\022\022\n\nindex_na" + + "me\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\026\n\016schema_v" + + "ersion\030\003 \001(\004\"C\n\031PauseFileActivityRespons" + + "e\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(" + + "\t\"C\n\031ResumeFileActivityRequest\022\022\n\nindex_" + + "name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\"D\n\032Resume" + + "FileActivityResponse\022\022\n\nindex_name\030\001 \001(\t" + + "\022\022\n\nshard_name\030\002 \001(\t\":\n\020ListFilesRequest" + + "\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t" + + "\"O\n\021ListFilesResponse\022\022\n\nindex_name\030\001 \001(" + + "\t\022\022\n\nshard_name\030\002 \001(\t\022\022\n\nfile_names\030\003 \003(" + + "\t\"S\n\026GetFileMetadataRequest\022\022\n\nindex_nam" + + "e\030\001 \001(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name" + + "\030\003 \001(\t\"f\n\014FileMetadata\022\022\n\nindex_name\030\001 \001" + + "(\t\022\022\n\nshard_name\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(" + + "\t\022\014\n\004size\030\004 \001(\003\022\r\n\005crc32\030\005 \001(\r\"~\n\016GetFil" + + "eRequest\022\022\n\nindex_name\030\001 \001(\t\022\022\n\nshard_na" + + "me\030\002 \001(\t\022\021\n\tfile_name\030\003 \001(\t\0221\n\013compressi" + + "on\030\004 \001(\0162\034.weaviate.v1.CompressionType\"6" + + "\n\tFileChunk\022\016\n\006offset\030\001 \001(\003\022\014\n\004data\030\002 \001(" + + "\014\022\013\n\003eof\030\003 \001(\010*\207\001\n\017CompressionType\022 \n\034CO" + + "MPRESSION_TYPE_UNSPECIFIED\020\000\022\031\n\025COMPRESS" + + "ION_TYPE_GZIP\020\001\022\031\n\025COMPRESSION_TYPE_ZLIB" + + "\020\002\022\034\n\030COMPRESSION_TYPE_DEFLATE\020\0032\312\003\n\026Fil" + + "eReplicationService\022b\n\021PauseFileActivity" + + "\022%.weaviate.v1.PauseFileActivityRequest\032" + + "&.weaviate.v1.PauseFileActivityResponse\022" + + "e\n\022ResumeFileActivity\022&.weaviate.v1.Resu" + + "meFileActivityRequest\032\'.weaviate.v1.Resu" + + "meFileActivityResponse\022J\n\tListFiles\022\035.we" + + "aviate.v1.ListFilesRequest\032\036.weaviate.v1" + + ".ListFilesResponse\022U\n\017GetFileMetadata\022#." + + "weaviate.v1.GetFileMetadataRequest\032\031.wea" + + "viate.v1.FileMetadata(\0010\001\022B\n\007GetFile\022\033.w" + + "eaviate.v1.GetFileRequest\032\026.weaviate.v1." + + "FileChunk(\0010\001BM\n-io.weaviate.client6.v1." + + "internal.grpc.protocolB\034WeaviateProtoFil" + + "eReplicationb\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }); + internal_static_weaviate_v1_PauseFileActivityRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_weaviate_v1_PauseFileActivityRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_PauseFileActivityRequest_descriptor, + new java.lang.String[] { "IndexName", "ShardName", "SchemaVersion", }); + internal_static_weaviate_v1_PauseFileActivityResponse_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_weaviate_v1_PauseFileActivityResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_PauseFileActivityResponse_descriptor, + new java.lang.String[] { "IndexName", "ShardName", }); + internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_weaviate_v1_ResumeFileActivityRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ResumeFileActivityRequest_descriptor, + new java.lang.String[] { "IndexName", "ShardName", }); + internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_weaviate_v1_ResumeFileActivityResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ResumeFileActivityResponse_descriptor, + new java.lang.String[] { "IndexName", "ShardName", }); + internal_static_weaviate_v1_ListFilesRequest_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_weaviate_v1_ListFilesRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ListFilesRequest_descriptor, + new java.lang.String[] { "IndexName", "ShardName", }); + internal_static_weaviate_v1_ListFilesResponse_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_weaviate_v1_ListFilesResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ListFilesResponse_descriptor, + new java.lang.String[] { "IndexName", "ShardName", "FileNames", }); + internal_static_weaviate_v1_GetFileMetadataRequest_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_weaviate_v1_GetFileMetadataRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_GetFileMetadataRequest_descriptor, + new java.lang.String[] { "IndexName", "ShardName", "FileName", }); + internal_static_weaviate_v1_FileMetadata_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_weaviate_v1_FileMetadata_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_FileMetadata_descriptor, + new java.lang.String[] { "IndexName", "ShardName", "FileName", "Size", "Crc32", }); + internal_static_weaviate_v1_GetFileRequest_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_weaviate_v1_GetFileRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_GetFileRequest_descriptor, + new java.lang.String[] { "IndexName", "ShardName", "FileName", "Compression", }); + internal_static_weaviate_v1_FileChunk_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_weaviate_v1_FileChunk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_FileChunk_descriptor, + new java.lang.String[] { "Offset", "Data", "Eof", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoGenerative.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoGenerative.java similarity index 75% rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoGenerative.java rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoGenerative.java index 65d2f5016..7b35c27ec 100644 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoGenerative.java +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoGenerative.java @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! // source: v1/generative.proto -package io.weaviate.client.grpc.protocol.v1; +package io.weaviate.client6.v1.internal.grpc.protocol; public final class WeaviateProtoGenerative { private WeaviateProtoGenerative() {} @@ -21,14 +21,14 @@ public interface GenerativeSearchOrBuilder extends /** * string single_response_prompt = 1 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated. - * See v1/generative.proto;l=26 + * See v1/generative.proto;l=25 * @return The singleResponsePrompt. */ @java.lang.Deprecated java.lang.String getSingleResponsePrompt(); /** * string single_response_prompt = 1 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated. - * See v1/generative.proto;l=26 + * See v1/generative.proto;l=25 * @return The bytes for singleResponsePrompt. */ @java.lang.Deprecated com.google.protobuf.ByteString @@ -37,14 +37,14 @@ public interface GenerativeSearchOrBuilder extends /** * string grouped_response_task = 2 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated. - * See v1/generative.proto;l=27 + * See v1/generative.proto;l=26 * @return The groupedResponseTask. */ @java.lang.Deprecated java.lang.String getGroupedResponseTask(); /** * string grouped_response_task = 2 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated. - * See v1/generative.proto;l=27 + * See v1/generative.proto;l=26 * @return The bytes for groupedResponseTask. */ @java.lang.Deprecated com.google.protobuf.ByteString @@ -53,7 +53,7 @@ public interface GenerativeSearchOrBuilder extends /** * repeated string grouped_properties = 3 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated. - * See v1/generative.proto;l=28 + * See v1/generative.proto;l=27 * @return A list containing the groupedProperties. */ @java.lang.Deprecated java.util.List @@ -61,14 +61,14 @@ public interface GenerativeSearchOrBuilder extends /** * repeated string grouped_properties = 3 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated. - * See v1/generative.proto;l=28 + * See v1/generative.proto;l=27 * @return The count of groupedProperties. */ @java.lang.Deprecated int getGroupedPropertiesCount(); /** * repeated string grouped_properties = 3 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated. - * See v1/generative.proto;l=28 + * See v1/generative.proto;l=27 * @param index The index of the element to return. * @return The groupedProperties at the given index. */ @@ -76,7 +76,7 @@ public interface GenerativeSearchOrBuilder extends /** * repeated string grouped_properties = 3 [deprecated = true]; * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated. - * See v1/generative.proto;l=28 + * See v1/generative.proto;l=27 * @param index The index of the value to return. * @return The bytes of the groupedProperties at the given index. */ @@ -92,11 +92,11 @@ public interface GenerativeSearchOrBuilder extends * .weaviate.v1.GenerativeSearch.Single single = 4; * @return The single. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getSingle(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getSingle(); /** * .weaviate.v1.GenerativeSearch.Single single = 4; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder(); /** * .weaviate.v1.GenerativeSearch.Grouped grouped = 5; @@ -107,11 +107,11 @@ public interface GenerativeSearchOrBuilder extends * .weaviate.v1.GenerativeSearch.Grouped grouped = 5; * @return The grouped. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped(); /** * .weaviate.v1.GenerativeSearch.Grouped grouped = 5; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder(); } /** * Protobuf type {@code weaviate.v1.GenerativeSearch} @@ -141,15 +141,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder.class); } public interface SingleOrBuilder extends @@ -181,7 +181,7 @@ public interface SingleOrBuilder extends * * repeated .weaviate.v1.GenerativeProvider queries = 3; */ - java.util.List + java.util.List getQueriesList(); /** *
@@ -190,7 +190,7 @@ public interface SingleOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index);
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index);
       /**
        * 
        * only allow one at the beginning, but multiple in the future
@@ -206,7 +206,7 @@ public interface SingleOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      java.util.List 
+      java.util.List 
           getQueriesOrBuilderList();
       /**
        * 
@@ -215,7 +215,7 @@ public interface SingleOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
           int index);
     }
     /**
@@ -244,15 +244,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder.class);
       }
 
       public static final int PROMPT_FIELD_NUMBER = 1;
@@ -307,7 +307,7 @@ public boolean getDebug() {
 
       public static final int QUERIES_FIELD_NUMBER = 3;
       @SuppressWarnings("serial")
-      private java.util.List queries_;
+      private java.util.List queries_;
       /**
        * 
        * only allow one at the beginning, but multiple in the future
@@ -316,7 +316,7 @@ public boolean getDebug() {
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public java.util.List getQueriesList() {
+      public java.util.List getQueriesList() {
         return queries_;
       }
       /**
@@ -327,7 +327,7 @@ public java.util.Listrepeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public java.util.List 
+      public java.util.List 
           getQueriesOrBuilderList() {
         return queries_;
       }
@@ -350,7 +350,7 @@ public int getQueriesCount() {
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
         return queries_.get(index);
       }
       /**
@@ -361,7 +361,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
           int index) {
         return queries_.get(index);
       }
@@ -419,10 +419,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single) obj;
 
         if (!getPrompt()
             .equals(other.getPrompt())) return false;
@@ -455,44 +455,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -500,26 +500,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -532,7 +532,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -553,21 +553,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeSearch.Single)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.newBuilder()
         private Builder() {
 
         }
@@ -596,17 +596,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Single_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -614,15 +614,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single(this);
           buildPartialRepeatedFields(result);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single result) {
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single result) {
           if (queriesBuilder_ == null) {
             if (((bitField0_ & 0x00000004) != 0)) {
               queries_ = java.util.Collections.unmodifiableList(queries_);
@@ -634,7 +634,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
           }
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.prompt_ = prompt_;
@@ -678,16 +678,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance()) return this;
           if (!other.getPrompt().isEmpty()) {
             prompt_ = other.prompt_;
             bitField0_ |= 0x00000001;
@@ -759,9 +759,9 @@ public Builder mergeFrom(
                   break;
                 } // case 16
                 case 26: {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider m =
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider m =
                       input.readMessage(
-                          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.parser(),
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.parser(),
                           extensionRegistry);
                   if (queriesBuilder_ == null) {
                     ensureQueriesIsMutable();
@@ -892,17 +892,17 @@ public Builder clearDebug() {
           return this;
         }
 
-        private java.util.List queries_ =
+        private java.util.List queries_ =
           java.util.Collections.emptyList();
         private void ensureQueriesIsMutable() {
           if (!((bitField0_ & 0x00000004) != 0)) {
-            queries_ = new java.util.ArrayList(queries_);
+            queries_ = new java.util.ArrayList(queries_);
             bitField0_ |= 0x00000004;
            }
         }
 
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder> queriesBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder> queriesBuilder_;
 
         /**
          * 
@@ -911,7 +911,7 @@ private void ensureQueriesIsMutable() {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List getQueriesList() {
+        public java.util.List getQueriesList() {
           if (queriesBuilder_ == null) {
             return java.util.Collections.unmodifiableList(queries_);
           } else {
@@ -939,7 +939,7 @@ public int getQueriesCount() {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
           if (queriesBuilder_ == null) {
             return queries_.get(index);
           } else {
@@ -954,7 +954,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder setQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -975,7 +975,7 @@ public Builder setQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder setQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.set(index, builderForValue.build());
@@ -992,7 +992,7 @@ public Builder setQueries(
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public Builder addQueries(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+        public Builder addQueries(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -1013,7 +1013,7 @@ public Builder addQueries(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGener
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -1034,7 +1034,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.add(builderForValue.build());
@@ -1052,7 +1052,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.add(index, builderForValue.build());
@@ -1070,7 +1070,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addAllQueries(
-            java.lang.Iterable values) {
+            java.lang.Iterable values) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -1122,7 +1122,7 @@ public Builder removeQueries(int index) {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder getQueriesBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder getQueriesBuilder(
             int index) {
           return getQueriesFieldBuilder().getBuilder(index);
         }
@@ -1133,7 +1133,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
             int index) {
           if (queriesBuilder_ == null) {
             return queries_.get(index);  } else {
@@ -1147,7 +1147,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List 
+        public java.util.List 
              getQueriesOrBuilderList() {
           if (queriesBuilder_ != null) {
             return queriesBuilder_.getMessageOrBuilderList();
@@ -1162,9 +1162,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder() {
           return getQueriesFieldBuilder().addBuilder(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
         }
         /**
          * 
@@ -1173,10 +1173,10 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder(
             int index) {
           return getQueriesFieldBuilder().addBuilder(
-              index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
         }
         /**
          * 
@@ -1185,16 +1185,16 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List 
+        public java.util.List 
              getQueriesBuilderList() {
           return getQueriesFieldBuilder().getBuilderList();
         }
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder> 
             getQueriesFieldBuilder() {
           if (queriesBuilder_ == null) {
             queriesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder>(
                     queries_,
                     ((bitField0_ & 0x00000004) != 0),
                     getParentForChildren(),
@@ -1220,12 +1220,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeSearch.Single)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -1261,7 +1261,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -1292,11 +1292,11 @@ public interface GroupedOrBuilder extends
        * optional .weaviate.v1.TextArray properties = 2;
        * @return The properties.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getProperties();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getProperties();
       /**
        * optional .weaviate.v1.TextArray properties = 2;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder();
 
       /**
        * 
@@ -1305,7 +1305,7 @@ public interface GroupedOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      java.util.List 
+      java.util.List 
           getQueriesList();
       /**
        * 
@@ -1314,7 +1314,7 @@ public interface GroupedOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index);
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index);
       /**
        * 
        * only allow one at the beginning, but multiple in the future
@@ -1330,7 +1330,7 @@ public interface GroupedOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      java.util.List 
+      java.util.List 
           getQueriesOrBuilderList();
       /**
        * 
@@ -1339,7 +1339,7 @@ public interface GroupedOrBuilder extends
        *
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
           int index);
 
       /**
@@ -1374,15 +1374,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder.class);
       }
 
       private int bitField0_;
@@ -1426,7 +1426,7 @@ public java.lang.String getTask() {
       }
 
       public static final int PROPERTIES_FIELD_NUMBER = 2;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray properties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray properties_;
       /**
        * optional .weaviate.v1.TextArray properties = 2;
        * @return Whether the properties field is set.
@@ -1440,20 +1440,20 @@ public boolean hasProperties() {
        * @return The properties.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getProperties() {
-        return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getProperties() {
+        return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
       }
       /**
        * optional .weaviate.v1.TextArray properties = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder() {
-        return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder() {
+        return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
       }
 
       public static final int QUERIES_FIELD_NUMBER = 3;
       @SuppressWarnings("serial")
-      private java.util.List queries_;
+      private java.util.List queries_;
       /**
        * 
        * only allow one at the beginning, but multiple in the future
@@ -1462,7 +1462,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public java.util.List getQueriesList() {
+      public java.util.List getQueriesList() {
         return queries_;
       }
       /**
@@ -1473,7 +1473,7 @@ public java.util.Listrepeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public java.util.List 
+      public java.util.List 
           getQueriesOrBuilderList() {
         return queries_;
       }
@@ -1496,7 +1496,7 @@ public int getQueriesCount() {
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
         return queries_.get(index);
       }
       /**
@@ -1507,7 +1507,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
        * repeated .weaviate.v1.GenerativeProvider queries = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
           int index) {
         return queries_.get(index);
       }
@@ -1583,10 +1583,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped) obj;
 
         if (!getTask()
             .equals(other.getTask())) return false;
@@ -1628,44 +1628,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -1673,26 +1673,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -1705,7 +1705,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -1726,21 +1726,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeSearch.Grouped)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.newBuilder()
         private Builder() {
           maybeForceBuilderInitialization();
         }
@@ -1781,17 +1781,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_Grouped_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -1799,15 +1799,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped(this);
           buildPartialRepeatedFields(result);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped result) {
+        private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped result) {
           if (queriesBuilder_ == null) {
             if (((bitField0_ & 0x00000004) != 0)) {
               queries_ = java.util.Collections.unmodifiableList(queries_);
@@ -1819,7 +1819,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
           }
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.task_ = task_;
@@ -1871,16 +1871,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance()) return this;
           if (!other.getTask().isEmpty()) {
             task_ = other.task_;
             bitField0_ |= 0x00000001;
@@ -1957,9 +1957,9 @@ public Builder mergeFrom(
                   break;
                 } // case 18
                 case 26: {
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider m =
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider m =
                       input.readMessage(
-                          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.parser(),
+                          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.parser(),
                           extensionRegistry);
                   if (queriesBuilder_ == null) {
                     ensureQueriesIsMutable();
@@ -2063,9 +2063,9 @@ public Builder setTaskBytes(
           return this;
         }
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray properties_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray properties_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> propertiesBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> propertiesBuilder_;
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          * @return Whether the properties field is set.
@@ -2077,9 +2077,9 @@ public boolean hasProperties() {
          * optional .weaviate.v1.TextArray properties = 2;
          * @return The properties.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getProperties() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getProperties() {
           if (propertiesBuilder_ == null) {
-            return properties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
+            return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
           } else {
             return propertiesBuilder_.getMessage();
           }
@@ -2087,7 +2087,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getProper
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          */
-        public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+        public Builder setProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
           if (propertiesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -2104,7 +2104,7 @@ public Builder setProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBa
          * optional .weaviate.v1.TextArray properties = 2;
          */
         public Builder setProperties(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
           if (propertiesBuilder_ == null) {
             properties_ = builderForValue.build();
           } else {
@@ -2117,11 +2117,11 @@ public Builder setProperties(
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          */
-        public Builder mergeProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+        public Builder mergeProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
           if (propertiesBuilder_ == null) {
             if (((bitField0_ & 0x00000002) != 0) &&
               properties_ != null &&
-              properties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+              properties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
               getPropertiesBuilder().mergeFrom(value);
             } else {
               properties_ = value;
@@ -2151,7 +2151,7 @@ public Builder clearProperties() {
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getPropertiesBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getPropertiesBuilder() {
           bitField0_ |= 0x00000002;
           onChanged();
           return getPropertiesFieldBuilder().getBuilder();
@@ -2159,23 +2159,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getPropertiesOrBuilder() {
           if (propertiesBuilder_ != null) {
             return propertiesBuilder_.getMessageOrBuilder();
           } else {
             return properties_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : properties_;
           }
         }
         /**
          * optional .weaviate.v1.TextArray properties = 2;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
             getPropertiesFieldBuilder() {
           if (propertiesBuilder_ == null) {
             propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                     getProperties(),
                     getParentForChildren(),
                     isClean());
@@ -2184,17 +2184,17 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
           return propertiesBuilder_;
         }
 
-        private java.util.List queries_ =
+        private java.util.List queries_ =
           java.util.Collections.emptyList();
         private void ensureQueriesIsMutable() {
           if (!((bitField0_ & 0x00000004) != 0)) {
-            queries_ = new java.util.ArrayList(queries_);
+            queries_ = new java.util.ArrayList(queries_);
             bitField0_ |= 0x00000004;
            }
         }
 
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder> queriesBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder> queriesBuilder_;
 
         /**
          * 
@@ -2203,7 +2203,7 @@ private void ensureQueriesIsMutable() {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List getQueriesList() {
+        public java.util.List getQueriesList() {
           if (queriesBuilder_ == null) {
             return java.util.Collections.unmodifiableList(queries_);
           } else {
@@ -2231,7 +2231,7 @@ public int getQueriesCount() {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getQueries(int index) {
           if (queriesBuilder_ == null) {
             return queries_.get(index);
           } else {
@@ -2246,7 +2246,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder setQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -2267,7 +2267,7 @@ public Builder setQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder setQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.set(index, builderForValue.build());
@@ -2284,7 +2284,7 @@ public Builder setQueries(
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public Builder addQueries(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+        public Builder addQueries(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -2305,7 +2305,7 @@ public Builder addQueries(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGener
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider value) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider value) {
           if (queriesBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -2326,7 +2326,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.add(builderForValue.build());
@@ -2344,7 +2344,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addQueries(
-            int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
+            int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder builderForValue) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             queries_.add(index, builderForValue.build());
@@ -2362,7 +2362,7 @@ public Builder addQueries(
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
         public Builder addAllQueries(
-            java.lang.Iterable values) {
+            java.lang.Iterable values) {
           if (queriesBuilder_ == null) {
             ensureQueriesIsMutable();
             com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -2414,7 +2414,7 @@ public Builder removeQueries(int index) {
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder getQueriesBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder getQueriesBuilder(
             int index) {
           return getQueriesFieldBuilder().getBuilder(index);
         }
@@ -2425,7 +2425,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder getQueriesOrBuilder(
             int index) {
           if (queriesBuilder_ == null) {
             return queries_.get(index);  } else {
@@ -2439,7 +2439,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List 
+        public java.util.List 
              getQueriesOrBuilderList() {
           if (queriesBuilder_ != null) {
             return queriesBuilder_.getMessageOrBuilderList();
@@ -2454,9 +2454,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder() {
           return getQueriesFieldBuilder().addBuilder(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
         }
         /**
          * 
@@ -2465,10 +2465,10 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder(
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder addQueriesBuilder(
             int index) {
           return getQueriesFieldBuilder().addBuilder(
-              index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
+              index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance());
         }
         /**
          * 
@@ -2477,16 +2477,16 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
          *
          * repeated .weaviate.v1.GenerativeProvider queries = 3;
          */
-        public java.util.List 
+        public java.util.List 
              getQueriesBuilderList() {
           return getQueriesFieldBuilder().getBuilderList();
         }
         private com.google.protobuf.RepeatedFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder> 
             getQueriesFieldBuilder() {
           if (queriesBuilder_ == null) {
             queriesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder>(
                     queries_,
                     ((bitField0_ & 0x00000004) != 0),
                     getParentForChildren(),
@@ -2544,12 +2544,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeSearch.Grouped)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -2585,7 +2585,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -2598,7 +2598,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * string single_response_prompt = 1 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-     *     See v1/generative.proto;l=26
+     *     See v1/generative.proto;l=25
      * @return The singleResponsePrompt.
      */
     @java.lang.Override
@@ -2617,7 +2617,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * string single_response_prompt = 1 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-     *     See v1/generative.proto;l=26
+     *     See v1/generative.proto;l=25
      * @return The bytes for singleResponsePrompt.
      */
     @java.lang.Override
@@ -2641,7 +2641,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * string grouped_response_task = 2 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-     *     See v1/generative.proto;l=27
+     *     See v1/generative.proto;l=26
      * @return The groupedResponseTask.
      */
     @java.lang.Override
@@ -2660,7 +2660,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * string grouped_response_task = 2 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-     *     See v1/generative.proto;l=27
+     *     See v1/generative.proto;l=26
      * @return The bytes for groupedResponseTask.
      */
     @java.lang.Override
@@ -2685,7 +2685,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * repeated string grouped_properties = 3 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-     *     See v1/generative.proto;l=28
+     *     See v1/generative.proto;l=27
      * @return A list containing the groupedProperties.
      */
     @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -2695,7 +2695,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * repeated string grouped_properties = 3 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-     *     See v1/generative.proto;l=28
+     *     See v1/generative.proto;l=27
      * @return The count of groupedProperties.
      */
     @java.lang.Deprecated public int getGroupedPropertiesCount() {
@@ -2704,7 +2704,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * repeated string grouped_properties = 3 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-     *     See v1/generative.proto;l=28
+     *     See v1/generative.proto;l=27
      * @param index The index of the element to return.
      * @return The groupedProperties at the given index.
      */
@@ -2714,7 +2714,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     /**
      * repeated string grouped_properties = 3 [deprecated = true];
      * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-     *     See v1/generative.proto;l=28
+     *     See v1/generative.proto;l=27
      * @param index The index of the value to return.
      * @return The bytes of the groupedProperties at the given index.
      */
@@ -2724,7 +2724,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
     }
 
     public static final int SINGLE_FIELD_NUMBER = 4;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single single_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single single_;
     /**
      * .weaviate.v1.GenerativeSearch.Single single = 4;
      * @return Whether the single field is set.
@@ -2738,19 +2738,19 @@ public boolean hasSingle() {
      * @return The single.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getSingle() {
-      return single_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getSingle() {
+      return single_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
     }
     /**
      * .weaviate.v1.GenerativeSearch.Single single = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder() {
-      return single_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder() {
+      return single_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
     }
 
     public static final int GROUPED_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped grouped_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped grouped_;
     /**
      * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
      * @return Whether the grouped field is set.
@@ -2764,15 +2764,15 @@ public boolean hasGrouped() {
      * @return The grouped.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped() {
-      return grouped_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped() {
+      return grouped_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
     }
     /**
      * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder() {
-      return grouped_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder() {
+      return grouped_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -2845,10 +2845,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch) obj;
 
       if (!getSingleResponsePrompt()
           .equals(other.getSingleResponsePrompt())) return false;
@@ -2898,44 +2898,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2943,26 +2943,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -2975,7 +2975,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -2996,21 +2996,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeSearch)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearchOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -3051,17 +3051,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeSearch_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -3069,14 +3069,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.singleResponsePrompt_ = singleResponsePrompt_;
@@ -3138,16 +3138,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance()) return this;
         if (!other.getSingleResponsePrompt().isEmpty()) {
           singleResponsePrompt_ = other.singleResponsePrompt_;
           bitField0_ |= 0x00000001;
@@ -3251,7 +3251,7 @@ public Builder mergeFrom(
       /**
        * string single_response_prompt = 1 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-       *     See v1/generative.proto;l=26
+       *     See v1/generative.proto;l=25
        * @return The singleResponsePrompt.
        */
       @java.lang.Deprecated public java.lang.String getSingleResponsePrompt() {
@@ -3269,7 +3269,7 @@ public Builder mergeFrom(
       /**
        * string single_response_prompt = 1 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-       *     See v1/generative.proto;l=26
+       *     See v1/generative.proto;l=25
        * @return The bytes for singleResponsePrompt.
        */
       @java.lang.Deprecated public com.google.protobuf.ByteString
@@ -3288,7 +3288,7 @@ public Builder mergeFrom(
       /**
        * string single_response_prompt = 1 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-       *     See v1/generative.proto;l=26
+       *     See v1/generative.proto;l=25
        * @param value The singleResponsePrompt to set.
        * @return This builder for chaining.
        */
@@ -3303,7 +3303,7 @@ public Builder mergeFrom(
       /**
        * string single_response_prompt = 1 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-       *     See v1/generative.proto;l=26
+       *     See v1/generative.proto;l=25
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearSingleResponsePrompt() {
@@ -3315,7 +3315,7 @@ public Builder mergeFrom(
       /**
        * string single_response_prompt = 1 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.single_response_prompt is deprecated.
-       *     See v1/generative.proto;l=26
+       *     See v1/generative.proto;l=25
        * @param value The bytes for singleResponsePrompt to set.
        * @return This builder for chaining.
        */
@@ -3333,7 +3333,7 @@ public Builder mergeFrom(
       /**
        * string grouped_response_task = 2 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-       *     See v1/generative.proto;l=27
+       *     See v1/generative.proto;l=26
        * @return The groupedResponseTask.
        */
       @java.lang.Deprecated public java.lang.String getGroupedResponseTask() {
@@ -3351,7 +3351,7 @@ public Builder mergeFrom(
       /**
        * string grouped_response_task = 2 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-       *     See v1/generative.proto;l=27
+       *     See v1/generative.proto;l=26
        * @return The bytes for groupedResponseTask.
        */
       @java.lang.Deprecated public com.google.protobuf.ByteString
@@ -3370,7 +3370,7 @@ public Builder mergeFrom(
       /**
        * string grouped_response_task = 2 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-       *     See v1/generative.proto;l=27
+       *     See v1/generative.proto;l=26
        * @param value The groupedResponseTask to set.
        * @return This builder for chaining.
        */
@@ -3385,7 +3385,7 @@ public Builder mergeFrom(
       /**
        * string grouped_response_task = 2 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-       *     See v1/generative.proto;l=27
+       *     See v1/generative.proto;l=26
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearGroupedResponseTask() {
@@ -3397,7 +3397,7 @@ public Builder mergeFrom(
       /**
        * string grouped_response_task = 2 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_response_task is deprecated.
-       *     See v1/generative.proto;l=27
+       *     See v1/generative.proto;l=26
        * @param value The bytes for groupedResponseTask to set.
        * @return This builder for chaining.
        */
@@ -3422,7 +3422,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @return A list containing the groupedProperties.
        */
       @java.lang.Deprecated public com.google.protobuf.ProtocolStringList
@@ -3433,7 +3433,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @return The count of groupedProperties.
        */
       @java.lang.Deprecated public int getGroupedPropertiesCount() {
@@ -3442,7 +3442,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param index The index of the element to return.
        * @return The groupedProperties at the given index.
        */
@@ -3452,7 +3452,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param index The index of the value to return.
        * @return The bytes of the groupedProperties at the given index.
        */
@@ -3463,7 +3463,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param index The index to set the value at.
        * @param value The groupedProperties to set.
        * @return This builder for chaining.
@@ -3480,7 +3480,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param value The groupedProperties to add.
        * @return This builder for chaining.
        */
@@ -3496,7 +3496,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param values The groupedProperties to add.
        * @return This builder for chaining.
        */
@@ -3512,7 +3512,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @return This builder for chaining.
        */
       @java.lang.Deprecated public Builder clearGroupedProperties() {
@@ -3525,7 +3525,7 @@ private void ensureGroupedPropertiesIsMutable() {
       /**
        * repeated string grouped_properties = 3 [deprecated = true];
        * @deprecated weaviate.v1.GenerativeSearch.grouped_properties is deprecated.
-       *     See v1/generative.proto;l=28
+       *     See v1/generative.proto;l=27
        * @param value The bytes of the groupedProperties to add.
        * @return This builder for chaining.
        */
@@ -3540,9 +3540,9 @@ private void ensureGroupedPropertiesIsMutable() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single single_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single single_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder> singleBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder> singleBuilder_;
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        * @return Whether the single field is set.
@@ -3554,9 +3554,9 @@ public boolean hasSingle() {
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        * @return The single.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single getSingle() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single getSingle() {
         if (singleBuilder_ == null) {
-          return single_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
+          return single_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
         } else {
           return singleBuilder_.getMessage();
         }
@@ -3564,7 +3564,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
-      public Builder setSingle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single value) {
+      public Builder setSingle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single value) {
         if (singleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -3581,7 +3581,7 @@ public Builder setSingle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
       public Builder setSingle(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder builderForValue) {
         if (singleBuilder_ == null) {
           single_ = builderForValue.build();
         } else {
@@ -3594,11 +3594,11 @@ public Builder setSingle(
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
-      public Builder mergeSingle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single value) {
+      public Builder mergeSingle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single value) {
         if (singleBuilder_ == null) {
           if (((bitField0_ & 0x00000008) != 0) &&
             single_ != null &&
-            single_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance()) {
+            single_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance()) {
             getSingleBuilder().mergeFrom(value);
           } else {
             single_ = value;
@@ -3628,7 +3628,7 @@ public Builder clearSingle() {
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder getSingleBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder getSingleBuilder() {
         bitField0_ |= 0x00000008;
         onChanged();
         return getSingleFieldBuilder().getBuilder();
@@ -3636,23 +3636,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder getSingleOrBuilder() {
         if (singleBuilder_ != null) {
           return singleBuilder_.getMessageOrBuilder();
         } else {
           return single_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.getDefaultInstance() : single_;
         }
       }
       /**
        * .weaviate.v1.GenerativeSearch.Single single = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder> 
           getSingleFieldBuilder() {
         if (singleBuilder_ == null) {
           singleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Single.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.SingleOrBuilder>(
                   getSingle(),
                   getParentForChildren(),
                   isClean());
@@ -3661,9 +3661,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
         return singleBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped grouped_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped grouped_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder> groupedBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder> groupedBuilder_;
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        * @return Whether the grouped field is set.
@@ -3675,9 +3675,9 @@ public boolean hasGrouped() {
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        * @return The grouped.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped getGrouped() {
         if (groupedBuilder_ == null) {
-          return grouped_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
+          return grouped_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
         } else {
           return groupedBuilder_.getMessage();
         }
@@ -3685,7 +3685,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
-      public Builder setGrouped(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped value) {
+      public Builder setGrouped(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped value) {
         if (groupedBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -3702,7 +3702,7 @@ public Builder setGrouped(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGener
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
       public Builder setGrouped(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder builderForValue) {
         if (groupedBuilder_ == null) {
           grouped_ = builderForValue.build();
         } else {
@@ -3715,11 +3715,11 @@ public Builder setGrouped(
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
-      public Builder mergeGrouped(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped value) {
+      public Builder mergeGrouped(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped value) {
         if (groupedBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             grouped_ != null &&
-            grouped_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance()) {
+            grouped_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance()) {
             getGroupedBuilder().mergeFrom(value);
           } else {
             grouped_ = value;
@@ -3749,7 +3749,7 @@ public Builder clearGrouped() {
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder getGroupedBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder getGroupedBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getGroupedFieldBuilder().getBuilder();
@@ -3757,23 +3757,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSea
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder getGroupedOrBuilder() {
         if (groupedBuilder_ != null) {
           return groupedBuilder_.getMessageOrBuilder();
         } else {
           return grouped_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.getDefaultInstance() : grouped_;
         }
       }
       /**
        * .weaviate.v1.GenerativeSearch.Grouped grouped = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder> 
           getGroupedFieldBuilder() {
         if (groupedBuilder_ == null) {
           groupedBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Grouped.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.GroupedOrBuilder>(
                   getGrouped(),
                   getParentForChildren(),
                   isClean());
@@ -3798,12 +3798,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeSearch)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3839,7 +3839,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeSearch getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -3864,11 +3864,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeAnthropic anthropic = 2;
      * @return The anthropic.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic();
     /**
      * .weaviate.v1.GenerativeAnthropic anthropic = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeAnyscale anyscale = 3;
@@ -3879,11 +3879,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeAnyscale anyscale = 3;
      * @return The anyscale.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale();
     /**
      * .weaviate.v1.GenerativeAnyscale anyscale = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeAWS aws = 4;
@@ -3894,11 +3894,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeAWS aws = 4;
      * @return The aws.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getAws();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getAws();
     /**
      * .weaviate.v1.GenerativeAWS aws = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeCohere cohere = 5;
@@ -3909,11 +3909,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeCohere cohere = 5;
      * @return The cohere.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getCohere();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getCohere();
     /**
      * .weaviate.v1.GenerativeCohere cohere = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeDummy dummy = 6;
@@ -3924,11 +3924,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeDummy dummy = 6;
      * @return The dummy.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDummy();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDummy();
     /**
      * .weaviate.v1.GenerativeDummy dummy = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeMistral mistral = 7;
@@ -3939,11 +3939,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeMistral mistral = 7;
      * @return The mistral.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getMistral();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getMistral();
     /**
      * .weaviate.v1.GenerativeMistral mistral = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeOllama ollama = 8;
@@ -3954,11 +3954,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeOllama ollama = 8;
      * @return The ollama.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getOllama();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getOllama();
     /**
      * .weaviate.v1.GenerativeOllama ollama = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeOpenAI openai = 9;
@@ -3969,11 +3969,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeOpenAI openai = 9;
      * @return The openai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getOpenai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getOpenai();
     /**
      * .weaviate.v1.GenerativeOpenAI openai = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeGoogle google = 10;
@@ -3984,11 +3984,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeGoogle google = 10;
      * @return The google.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getGoogle();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getGoogle();
     /**
      * .weaviate.v1.GenerativeGoogle google = 10;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeDatabricks databricks = 11;
@@ -3999,11 +3999,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeDatabricks databricks = 11;
      * @return The databricks.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks();
     /**
      * .weaviate.v1.GenerativeDatabricks databricks = 11;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
@@ -4014,11 +4014,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
      * @return The friendliai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai();
     /**
      * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeNvidia nvidia = 13;
@@ -4029,11 +4029,11 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeNvidia nvidia = 13;
      * @return The nvidia.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getNvidia();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getNvidia();
     /**
      * .weaviate.v1.GenerativeNvidia nvidia = 13;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeXAI xai = 14;
@@ -4044,13 +4044,13 @@ public interface GenerativeProviderOrBuilder extends
      * .weaviate.v1.GenerativeXAI xai = 14;
      * @return The xai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getXai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getXai();
     /**
      * .weaviate.v1.GenerativeXAI xai = 14;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.KindCase getKindCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.KindCase getKindCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeProvider}
@@ -4076,15 +4076,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder.class);
     }
 
     private int kindCase_ = 0;
@@ -4176,21 +4176,21 @@ public boolean hasAnthropic() {
      * @return The anthropic.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic() {
       if (kindCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAnthropic anthropic = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder() {
       if (kindCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
     }
 
     public static final int ANYSCALE_FIELD_NUMBER = 3;
@@ -4207,21 +4207,21 @@ public boolean hasAnyscale() {
      * @return The anyscale.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale() {
       if (kindCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAnyscale anyscale = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder() {
       if (kindCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
     }
 
     public static final int AWS_FIELD_NUMBER = 4;
@@ -4238,21 +4238,21 @@ public boolean hasAws() {
      * @return The aws.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getAws() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getAws() {
       if (kindCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAWS aws = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder() {
       if (kindCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
     }
 
     public static final int COHERE_FIELD_NUMBER = 5;
@@ -4269,21 +4269,21 @@ public boolean hasCohere() {
      * @return The cohere.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getCohere() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getCohere() {
       if (kindCase_ == 5) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeCohere cohere = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder() {
       if (kindCase_ == 5) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
     }
 
     public static final int DUMMY_FIELD_NUMBER = 6;
@@ -4300,21 +4300,21 @@ public boolean hasDummy() {
      * @return The dummy.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDummy() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDummy() {
       if (kindCase_ == 6) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeDummy dummy = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder() {
       if (kindCase_ == 6) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
     }
 
     public static final int MISTRAL_FIELD_NUMBER = 7;
@@ -4331,21 +4331,21 @@ public boolean hasMistral() {
      * @return The mistral.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getMistral() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getMistral() {
       if (kindCase_ == 7) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeMistral mistral = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder() {
       if (kindCase_ == 7) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
     }
 
     public static final int OLLAMA_FIELD_NUMBER = 8;
@@ -4362,21 +4362,21 @@ public boolean hasOllama() {
      * @return The ollama.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getOllama() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getOllama() {
       if (kindCase_ == 8) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeOllama ollama = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder() {
       if (kindCase_ == 8) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
     }
 
     public static final int OPENAI_FIELD_NUMBER = 9;
@@ -4393,21 +4393,21 @@ public boolean hasOpenai() {
      * @return The openai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getOpenai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getOpenai() {
       if (kindCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeOpenAI openai = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder() {
       if (kindCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
     }
 
     public static final int GOOGLE_FIELD_NUMBER = 10;
@@ -4424,21 +4424,21 @@ public boolean hasGoogle() {
      * @return The google.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getGoogle() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getGoogle() {
       if (kindCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeGoogle google = 10;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder() {
       if (kindCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
     }
 
     public static final int DATABRICKS_FIELD_NUMBER = 11;
@@ -4455,21 +4455,21 @@ public boolean hasDatabricks() {
      * @return The databricks.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks() {
       if (kindCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeDatabricks databricks = 11;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder() {
       if (kindCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
     }
 
     public static final int FRIENDLIAI_FIELD_NUMBER = 12;
@@ -4486,21 +4486,21 @@ public boolean hasFriendliai() {
      * @return The friendliai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai() {
       if (kindCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder() {
       if (kindCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
     }
 
     public static final int NVIDIA_FIELD_NUMBER = 13;
@@ -4517,21 +4517,21 @@ public boolean hasNvidia() {
      * @return The nvidia.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getNvidia() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getNvidia() {
       if (kindCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeNvidia nvidia = 13;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder() {
       if (kindCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
     }
 
     public static final int XAI_FIELD_NUMBER = 14;
@@ -4548,21 +4548,21 @@ public boolean hasXai() {
      * @return The xai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getXai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getXai() {
       if (kindCase_ == 14) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeXAI xai = 14;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder() {
       if (kindCase_ == 14) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
     }
 
     private byte memoizedIsInitialized = -1;
@@ -4583,43 +4583,43 @@ public void writeTo(com.google.protobuf.CodedOutputStream output)
         output.writeBool(1, returnMetadata_);
       }
       if (kindCase_ == 2) {
-        output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_);
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_);
       }
       if (kindCase_ == 3) {
-        output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_);
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_);
       }
       if (kindCase_ == 4) {
-        output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_);
+        output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_);
       }
       if (kindCase_ == 5) {
-        output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_);
+        output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_);
       }
       if (kindCase_ == 6) {
-        output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_);
+        output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_);
       }
       if (kindCase_ == 7) {
-        output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_);
+        output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_);
       }
       if (kindCase_ == 8) {
-        output.writeMessage(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_);
+        output.writeMessage(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_);
       }
       if (kindCase_ == 9) {
-        output.writeMessage(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_);
+        output.writeMessage(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_);
       }
       if (kindCase_ == 10) {
-        output.writeMessage(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_);
+        output.writeMessage(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_);
       }
       if (kindCase_ == 11) {
-        output.writeMessage(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_);
+        output.writeMessage(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_);
       }
       if (kindCase_ == 12) {
-        output.writeMessage(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_);
+        output.writeMessage(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_);
       }
       if (kindCase_ == 13) {
-        output.writeMessage(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_);
+        output.writeMessage(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_);
       }
       if (kindCase_ == 14) {
-        output.writeMessage(14, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_);
+        output.writeMessage(14, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -4636,55 +4636,55 @@ public int getSerializedSize() {
       }
       if (kindCase_ == 2) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_);
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_);
       }
       if (kindCase_ == 3) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_);
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_);
       }
       if (kindCase_ == 4) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_);
+          .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_);
       }
       if (kindCase_ == 5) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_);
+          .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_);
       }
       if (kindCase_ == 6) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_);
+          .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_);
       }
       if (kindCase_ == 7) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_);
+          .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_);
       }
       if (kindCase_ == 8) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_);
+          .computeMessageSize(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_);
       }
       if (kindCase_ == 9) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_);
+          .computeMessageSize(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_);
       }
       if (kindCase_ == 10) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_);
+          .computeMessageSize(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_);
       }
       if (kindCase_ == 11) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_);
+          .computeMessageSize(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_);
       }
       if (kindCase_ == 12) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_);
+          .computeMessageSize(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_);
       }
       if (kindCase_ == 13) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_);
+          .computeMessageSize(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_);
       }
       if (kindCase_ == 14) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(14, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_);
+          .computeMessageSize(14, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSize = size;
@@ -4696,10 +4696,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider) obj;
 
       if (getReturnMetadata()
           != other.getReturnMetadata()) return false;
@@ -4835,44 +4835,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4880,26 +4880,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -4912,7 +4912,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -4933,21 +4933,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeProvider)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProviderOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProviderOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.newBuilder()
       private Builder() {
 
       }
@@ -5009,17 +5009,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeProvider_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -5027,22 +5027,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativePro
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.returnMetadata_ = returnMetadata_;
         }
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider result) {
         result.kindCase_ = kindCase_;
         result.kind_ = this.kind_;
         if (kindCase_ == 2 &&
@@ -5133,16 +5133,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider.getDefaultInstance()) return this;
         if (other.getReturnMetadata() != false) {
           setReturnMetadata(other.getReturnMetadata());
         }
@@ -5390,7 +5390,7 @@ public Builder clearReturnMetadata() {
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder> anthropicBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder> anthropicBuilder_;
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        * @return Whether the anthropic field is set.
@@ -5404,23 +5404,23 @@ public boolean hasAnthropic() {
        * @return The anthropic.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getAnthropic() {
         if (anthropicBuilder_ == null) {
           if (kindCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
         } else {
           if (kindCase_ == 2) {
             return anthropicBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
-      public Builder setAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic value) {
+      public Builder setAnthropic(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic value) {
         if (anthropicBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5437,7 +5437,7 @@ public Builder setAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGen
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
       public Builder setAnthropic(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder builderForValue) {
         if (anthropicBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -5450,11 +5450,11 @@ public Builder setAnthropic(
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
-      public Builder mergeAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic value) {
+      public Builder mergeAnthropic(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic value) {
         if (anthropicBuilder_ == null) {
           if (kindCase_ == 2 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -5492,36 +5492,36 @@ public Builder clearAnthropic() {
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder getAnthropicBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder getAnthropicBuilder() {
         return getAnthropicFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder getAnthropicOrBuilder() {
         if ((kindCase_ == 2) && (anthropicBuilder_ != null)) {
           return anthropicBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnthropic anthropic = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder> 
           getAnthropicFieldBuilder() {
         if (anthropicBuilder_ == null) {
           if (!(kindCase_ == 2)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
           }
           anthropicBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -5532,7 +5532,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder> anyscaleBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder> anyscaleBuilder_;
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        * @return Whether the anyscale field is set.
@@ -5546,23 +5546,23 @@ public boolean hasAnyscale() {
        * @return The anyscale.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getAnyscale() {
         if (anyscaleBuilder_ == null) {
           if (kindCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
         } else {
           if (kindCase_ == 3) {
             return anyscaleBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
-      public Builder setAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale value) {
+      public Builder setAnyscale(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale value) {
         if (anyscaleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5579,7 +5579,7 @@ public Builder setAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGene
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
       public Builder setAnyscale(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder builderForValue) {
         if (anyscaleBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -5592,11 +5592,11 @@ public Builder setAnyscale(
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
-      public Builder mergeAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale value) {
+      public Builder mergeAnyscale(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale value) {
         if (anyscaleBuilder_ == null) {
           if (kindCase_ == 3 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -5634,36 +5634,36 @@ public Builder clearAnyscale() {
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder getAnyscaleBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder getAnyscaleBuilder() {
         return getAnyscaleFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder getAnyscaleOrBuilder() {
         if ((kindCase_ == 3) && (anyscaleBuilder_ != null)) {
           return anyscaleBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnyscale anyscale = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder> 
           getAnyscaleFieldBuilder() {
         if (anyscaleBuilder_ == null) {
           if (!(kindCase_ == 3)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
           }
           anyscaleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -5674,7 +5674,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAny
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder> awsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder> awsBuilder_;
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        * @return Whether the aws field is set.
@@ -5688,23 +5688,23 @@ public boolean hasAws() {
        * @return The aws.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getAws() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getAws() {
         if (awsBuilder_ == null) {
           if (kindCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
         } else {
           if (kindCase_ == 4) {
             return awsBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
-      public Builder setAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS value) {
+      public Builder setAws(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS value) {
         if (awsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5721,7 +5721,7 @@ public Builder setAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerativ
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
       public Builder setAws(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder builderForValue) {
         if (awsBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -5734,11 +5734,11 @@ public Builder setAws(
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
-      public Builder mergeAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS value) {
+      public Builder mergeAws(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS value) {
         if (awsBuilder_ == null) {
           if (kindCase_ == 4 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -5776,36 +5776,36 @@ public Builder clearAws() {
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder getAwsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder getAwsBuilder() {
         return getAwsFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder getAwsOrBuilder() {
         if ((kindCase_ == 4) && (awsBuilder_ != null)) {
           return awsBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAWS aws = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder> 
           getAwsFieldBuilder() {
         if (awsBuilder_ == null) {
           if (!(kindCase_ == 4)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
           }
           awsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -5816,7 +5816,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder> cohereBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder> cohereBuilder_;
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        * @return Whether the cohere field is set.
@@ -5830,23 +5830,23 @@ public boolean hasCohere() {
        * @return The cohere.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getCohere() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getCohere() {
         if (cohereBuilder_ == null) {
           if (kindCase_ == 5) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
         } else {
           if (kindCase_ == 5) {
             return cohereBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
-      public Builder setCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere value) {
+      public Builder setCohere(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere value) {
         if (cohereBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -5863,7 +5863,7 @@ public Builder setCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
       public Builder setCohere(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder builderForValue) {
         if (cohereBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -5876,11 +5876,11 @@ public Builder setCohere(
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
-      public Builder mergeCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere value) {
+      public Builder mergeCohere(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere value) {
         if (cohereBuilder_ == null) {
           if (kindCase_ == 5 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -5918,36 +5918,36 @@ public Builder clearCohere() {
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder getCohereBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder getCohereBuilder() {
         return getCohereFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder getCohereOrBuilder() {
         if ((kindCase_ == 5) && (cohereBuilder_ != null)) {
           return cohereBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 5) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeCohere cohere = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder> 
           getCohereFieldBuilder() {
         if (cohereBuilder_ == null) {
           if (!(kindCase_ == 5)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
           }
           cohereBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -5958,7 +5958,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder> dummyBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder> dummyBuilder_;
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        * @return Whether the dummy field is set.
@@ -5972,23 +5972,23 @@ public boolean hasDummy() {
        * @return The dummy.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDummy() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDummy() {
         if (dummyBuilder_ == null) {
           if (kindCase_ == 6) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
         } else {
           if (kindCase_ == 6) {
             return dummyBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
-      public Builder setDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy value) {
+      public Builder setDummy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy value) {
         if (dummyBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6005,7 +6005,7 @@ public Builder setDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
       public Builder setDummy(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder builderForValue) {
         if (dummyBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6018,11 +6018,11 @@ public Builder setDummy(
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
-      public Builder mergeDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy value) {
+      public Builder mergeDummy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy value) {
         if (dummyBuilder_ == null) {
           if (kindCase_ == 6 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6060,36 +6060,36 @@ public Builder clearDummy() {
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder getDummyBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder getDummyBuilder() {
         return getDummyFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder getDummyOrBuilder() {
         if ((kindCase_ == 6) && (dummyBuilder_ != null)) {
           return dummyBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 6) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDummy dummy = 6;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder> 
           getDummyFieldBuilder() {
         if (dummyBuilder_ == null) {
           if (!(kindCase_ == 6)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
           }
           dummyBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6100,7 +6100,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDum
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder> mistralBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder> mistralBuilder_;
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        * @return Whether the mistral field is set.
@@ -6114,23 +6114,23 @@ public boolean hasMistral() {
        * @return The mistral.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getMistral() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getMistral() {
         if (mistralBuilder_ == null) {
           if (kindCase_ == 7) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
         } else {
           if (kindCase_ == 7) {
             return mistralBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
-      public Builder setMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral value) {
+      public Builder setMistral(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral value) {
         if (mistralBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6147,7 +6147,7 @@ public Builder setMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGener
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
       public Builder setMistral(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder builderForValue) {
         if (mistralBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6160,11 +6160,11 @@ public Builder setMistral(
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
-      public Builder mergeMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral value) {
+      public Builder mergeMistral(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral value) {
         if (mistralBuilder_ == null) {
           if (kindCase_ == 7 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6202,36 +6202,36 @@ public Builder clearMistral() {
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder getMistralBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder getMistralBuilder() {
         return getMistralFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder getMistralOrBuilder() {
         if ((kindCase_ == 7) && (mistralBuilder_ != null)) {
           return mistralBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 7) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeMistral mistral = 7;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder> 
           getMistralFieldBuilder() {
         if (mistralBuilder_ == null) {
           if (!(kindCase_ == 7)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
           }
           mistralBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6242,7 +6242,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder> ollamaBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder> ollamaBuilder_;
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        * @return Whether the ollama field is set.
@@ -6256,23 +6256,23 @@ public boolean hasOllama() {
        * @return The ollama.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getOllama() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getOllama() {
         if (ollamaBuilder_ == null) {
           if (kindCase_ == 8) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
         } else {
           if (kindCase_ == 8) {
             return ollamaBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
-      public Builder setOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama value) {
+      public Builder setOllama(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama value) {
         if (ollamaBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6289,7 +6289,7 @@ public Builder setOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
       public Builder setOllama(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder builderForValue) {
         if (ollamaBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6302,11 +6302,11 @@ public Builder setOllama(
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
-      public Builder mergeOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama value) {
+      public Builder mergeOllama(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama value) {
         if (ollamaBuilder_ == null) {
           if (kindCase_ == 8 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6344,36 +6344,36 @@ public Builder clearOllama() {
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder getOllamaBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder getOllamaBuilder() {
         return getOllamaFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder getOllamaOrBuilder() {
         if ((kindCase_ == 8) && (ollamaBuilder_ != null)) {
           return ollamaBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 8) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOllama ollama = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder> 
           getOllamaFieldBuilder() {
         if (ollamaBuilder_ == null) {
           if (!(kindCase_ == 8)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
           }
           ollamaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6384,7 +6384,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOll
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder> openaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder> openaiBuilder_;
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        * @return Whether the openai field is set.
@@ -6398,23 +6398,23 @@ public boolean hasOpenai() {
        * @return The openai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getOpenai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getOpenai() {
         if (openaiBuilder_ == null) {
           if (kindCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
         } else {
           if (kindCase_ == 9) {
             return openaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
-      public Builder setOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI value) {
+      public Builder setOpenai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI value) {
         if (openaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6431,7 +6431,7 @@ public Builder setOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
       public Builder setOpenai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder builderForValue) {
         if (openaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6444,11 +6444,11 @@ public Builder setOpenai(
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
-      public Builder mergeOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI value) {
+      public Builder mergeOpenai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI value) {
         if (openaiBuilder_ == null) {
           if (kindCase_ == 9 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6486,36 +6486,36 @@ public Builder clearOpenai() {
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder getOpenaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder getOpenaiBuilder() {
         return getOpenaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder getOpenaiOrBuilder() {
         if ((kindCase_ == 9) && (openaiBuilder_ != null)) {
           return openaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOpenAI openai = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder> 
           getOpenaiFieldBuilder() {
         if (openaiBuilder_ == null) {
           if (!(kindCase_ == 9)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
           }
           openaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6526,7 +6526,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder> googleBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder> googleBuilder_;
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        * @return Whether the google field is set.
@@ -6540,23 +6540,23 @@ public boolean hasGoogle() {
        * @return The google.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getGoogle() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getGoogle() {
         if (googleBuilder_ == null) {
           if (kindCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
         } else {
           if (kindCase_ == 10) {
             return googleBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
-      public Builder setGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle value) {
+      public Builder setGoogle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle value) {
         if (googleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6573,7 +6573,7 @@ public Builder setGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
       public Builder setGoogle(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder builderForValue) {
         if (googleBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6586,11 +6586,11 @@ public Builder setGoogle(
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
-      public Builder mergeGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle value) {
+      public Builder mergeGoogle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle value) {
         if (googleBuilder_ == null) {
           if (kindCase_ == 10 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6628,36 +6628,36 @@ public Builder clearGoogle() {
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder getGoogleBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder getGoogleBuilder() {
         return getGoogleFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder getGoogleOrBuilder() {
         if ((kindCase_ == 10) && (googleBuilder_ != null)) {
           return googleBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeGoogle google = 10;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder> 
           getGoogleFieldBuilder() {
         if (googleBuilder_ == null) {
           if (!(kindCase_ == 10)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
           }
           googleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6668,7 +6668,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder> databricksBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder> databricksBuilder_;
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        * @return Whether the databricks field is set.
@@ -6682,23 +6682,23 @@ public boolean hasDatabricks() {
        * @return The databricks.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDatabricks() {
         if (databricksBuilder_ == null) {
           if (kindCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
         } else {
           if (kindCase_ == 11) {
             return databricksBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
-      public Builder setDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks value) {
+      public Builder setDatabricks(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks value) {
         if (databricksBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6715,7 +6715,7 @@ public Builder setDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGe
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
       public Builder setDatabricks(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder builderForValue) {
         if (databricksBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6728,11 +6728,11 @@ public Builder setDatabricks(
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
-      public Builder mergeDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks value) {
+      public Builder mergeDatabricks(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks value) {
         if (databricksBuilder_ == null) {
           if (kindCase_ == 11 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6770,36 +6770,36 @@ public Builder clearDatabricks() {
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder getDatabricksBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder getDatabricksBuilder() {
         return getDatabricksFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder getDatabricksOrBuilder() {
         if ((kindCase_ == 11) && (databricksBuilder_ != null)) {
           return databricksBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDatabricks databricks = 11;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder> 
           getDatabricksFieldBuilder() {
         if (databricksBuilder_ == null) {
           if (!(kindCase_ == 11)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
           }
           databricksBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6810,7 +6810,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder> friendliaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder> friendliaiBuilder_;
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        * @return Whether the friendliai field is set.
@@ -6824,23 +6824,23 @@ public boolean hasFriendliai() {
        * @return The friendliai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getFriendliai() {
         if (friendliaiBuilder_ == null) {
           if (kindCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
         } else {
           if (kindCase_ == 12) {
             return friendliaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
-      public Builder setFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI value) {
+      public Builder setFriendliai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI value) {
         if (friendliaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6857,7 +6857,7 @@ public Builder setFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGe
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
       public Builder setFriendliai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder builderForValue) {
         if (friendliaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -6870,11 +6870,11 @@ public Builder setFriendliai(
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
-      public Builder mergeFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI value) {
+      public Builder mergeFriendliai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI value) {
         if (friendliaiBuilder_ == null) {
           if (kindCase_ == 12 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -6912,36 +6912,36 @@ public Builder clearFriendliai() {
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder getFriendliaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder getFriendliaiBuilder() {
         return getFriendliaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder getFriendliaiOrBuilder() {
         if ((kindCase_ == 12) && (friendliaiBuilder_ != null)) {
           return friendliaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeFriendliAI friendliai = 12;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder> 
           getFriendliaiFieldBuilder() {
         if (friendliaiBuilder_ == null) {
           if (!(kindCase_ == 12)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
           }
           friendliaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -6952,7 +6952,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder> nvidiaBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder> nvidiaBuilder_;
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        * @return Whether the nvidia field is set.
@@ -6966,23 +6966,23 @@ public boolean hasNvidia() {
        * @return The nvidia.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getNvidia() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getNvidia() {
         if (nvidiaBuilder_ == null) {
           if (kindCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
         } else {
           if (kindCase_ == 13) {
             return nvidiaBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
-      public Builder setNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia value) {
+      public Builder setNvidia(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia value) {
         if (nvidiaBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -6999,7 +6999,7 @@ public Builder setNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
       public Builder setNvidia(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder builderForValue) {
         if (nvidiaBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -7012,11 +7012,11 @@ public Builder setNvidia(
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
-      public Builder mergeNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia value) {
+      public Builder mergeNvidia(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia value) {
         if (nvidiaBuilder_ == null) {
           if (kindCase_ == 13 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -7054,36 +7054,36 @@ public Builder clearNvidia() {
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder getNvidiaBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder getNvidiaBuilder() {
         return getNvidiaFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder getNvidiaOrBuilder() {
         if ((kindCase_ == 13) && (nvidiaBuilder_ != null)) {
           return nvidiaBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeNvidia nvidia = 13;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder> 
           getNvidiaFieldBuilder() {
         if (nvidiaBuilder_ == null) {
           if (!(kindCase_ == 13)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
           }
           nvidiaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -7094,7 +7094,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder> xaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder> xaiBuilder_;
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        * @return Whether the xai field is set.
@@ -7108,23 +7108,23 @@ public boolean hasXai() {
        * @return The xai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getXai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getXai() {
         if (xaiBuilder_ == null) {
           if (kindCase_ == 14) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
         } else {
           if (kindCase_ == 14) {
             return xaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
-      public Builder setXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI value) {
+      public Builder setXai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI value) {
         if (xaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -7141,7 +7141,7 @@ public Builder setXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerativ
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
       public Builder setXai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder builderForValue) {
         if (xaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -7154,11 +7154,11 @@ public Builder setXai(
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
-      public Builder mergeXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI value) {
+      public Builder mergeXai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI value) {
         if (xaiBuilder_ == null) {
           if (kindCase_ == 14 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -7196,36 +7196,36 @@ public Builder clearXai() {
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder getXaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder getXaiBuilder() {
         return getXaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder getXaiOrBuilder() {
         if ((kindCase_ == 14) && (xaiBuilder_ != null)) {
           return xaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 14) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeXAI xai = 14;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder> 
           getXaiFieldBuilder() {
         if (xaiBuilder_ == null) {
           if (!(kindCase_ == 14)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
           }
           xaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -7251,12 +7251,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeProvider)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -7292,7 +7292,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeProvider getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeProvider getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -7389,11 +7389,11 @@ public interface GenerativeAnthropicOrBuilder extends
      * optional .weaviate.v1.TextArray stop_sequences = 7;
      * @return The stopSequences.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences();
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray images = 8;
@@ -7404,11 +7404,11 @@ public interface GenerativeAnthropicOrBuilder extends
      * optional .weaviate.v1.TextArray images = 8;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 9;
@@ -7419,11 +7419,11 @@ public interface GenerativeAnthropicOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 9;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeAnthropic}
@@ -7451,15 +7451,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder.class);
     }
 
     private int bitField0_;
@@ -7634,7 +7634,7 @@ public double getTopP() {
     }
 
     public static final int STOP_SEQUENCES_FIELD_NUMBER = 7;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 7;
      * @return Whether the stopSequences field is set.
@@ -7648,19 +7648,19 @@ public boolean hasStopSequences() {
      * @return The stopSequences.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
 
     public static final int IMAGES_FIELD_NUMBER = 8;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 8;
      * @return Whether the images field is set.
@@ -7674,19 +7674,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 9;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 9;
      * @return Whether the imageProperties field is set.
@@ -7700,15 +7700,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -7805,10 +7805,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -7913,44 +7913,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7958,26 +7958,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -7990,7 +7990,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -8011,21 +8011,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAnthropic)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -8074,17 +8074,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropic_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -8092,14 +8092,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -8181,16 +8181,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -8634,9 +8634,9 @@ public Builder clearTopP() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        * @return Whether the stopSequences field is set.
@@ -8648,9 +8648,9 @@ public boolean hasStopSequences() {
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        * @return The stopSequences.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
         if (stopSequencesBuilder_ == null) {
-          return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+          return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         } else {
           return stopSequencesBuilder_.getMessage();
         }
@@ -8658,7 +8658,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSe
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
-      public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -8675,7 +8675,7 @@ public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProt
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
       public Builder setStopSequences(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (stopSequencesBuilder_ == null) {
           stopSequences_ = builderForValue.build();
         } else {
@@ -8688,11 +8688,11 @@ public Builder setStopSequences(
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
-      public Builder mergeStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (((bitField0_ & 0x00000040) != 0) &&
             stopSequences_ != null &&
-            stopSequences_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            stopSequences_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getStopSequencesBuilder().mergeFrom(value);
           } else {
             stopSequences_ = value;
@@ -8722,7 +8722,7 @@ public Builder clearStopSequences() {
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
         bitField0_ |= 0x00000040;
         onChanged();
         return getStopSequencesFieldBuilder().getBuilder();
@@ -8730,23 +8730,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
         if (stopSequencesBuilder_ != null) {
           return stopSequencesBuilder_.getMessageOrBuilder();
         } else {
           return stopSequences_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 7;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getStopSequencesFieldBuilder() {
         if (stopSequencesBuilder_ == null) {
           stopSequencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getStopSequences(),
                   getParentForChildren(),
                   isClean());
@@ -8755,9 +8755,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return stopSequencesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 8;
        * @return Whether the images field is set.
@@ -8769,9 +8769,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 8;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -8779,7 +8779,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 8;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -8796,7 +8796,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 8;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -8809,11 +8809,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 8;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -8843,7 +8843,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -8851,23 +8851,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -8876,9 +8876,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        * @return Whether the imageProperties field is set.
@@ -8890,9 +8890,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 9;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -8900,7 +8900,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -8917,7 +8917,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -8930,11 +8930,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00000100) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -8964,7 +8964,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00000100;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -8972,23 +8972,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -9013,12 +9013,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAnthropic)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9054,7 +9054,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropic getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9135,15 +9135,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder.class);
     }
 
     private int bitField0_;
@@ -9312,10 +9312,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -9362,44 +9362,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9407,26 +9407,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -9439,7 +9439,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -9460,21 +9460,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAnyscale)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.newBuilder()
       private Builder() {
 
       }
@@ -9497,17 +9497,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscale_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -9515,14 +9515,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAny
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -9574,16 +9574,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -9869,12 +9869,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAnyscale)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -9910,7 +9910,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscale getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -10042,11 +10042,11 @@ public interface GenerativeAWSOrBuilder extends
      * optional .weaviate.v1.TextArray images = 14;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 14;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
@@ -10057,11 +10057,11 @@ public interface GenerativeAWSOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 15;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeAWS}
@@ -10093,15 +10093,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder.class);
     }
 
     private int bitField0_;
@@ -10407,7 +10407,7 @@ public java.lang.String getTargetVariant() {
     }
 
     public static final int IMAGES_FIELD_NUMBER = 14;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 14;
      * @return Whether the images field is set.
@@ -10421,19 +10421,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 14;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 15;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      * @return Whether the imageProperties field is set.
@@ -10447,15 +10447,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -10548,10 +10548,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) obj;
 
       if (hasModel() != other.hasModel()) return false;
       if (hasModel()) {
@@ -10652,44 +10652,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10697,26 +10697,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -10729,7 +10729,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -10750,21 +10750,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAWS)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -10808,17 +10808,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWS_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -10826,14 +10826,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -10913,16 +10913,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS.getDefaultInstance()) return this;
         if (other.hasModel()) {
           model_ = other.model_;
           bitField0_ |= 0x00000001;
@@ -11568,9 +11568,9 @@ public Builder setTargetVariantBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 14;
        * @return Whether the images field is set.
@@ -11582,9 +11582,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 14;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -11592,7 +11592,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11609,7 +11609,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 14;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -11622,11 +11622,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -11656,7 +11656,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -11664,23 +11664,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -11689,9 +11689,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        * @return Whether the imageProperties field is set.
@@ -11703,9 +11703,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 15;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -11713,7 +11713,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -11730,7 +11730,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -11743,11 +11743,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00000100) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -11777,7 +11777,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00000100;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -11785,23 +11785,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -11826,12 +11826,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAWS)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -11867,7 +11867,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWS getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -11975,11 +11975,11 @@ public interface GenerativeCohereOrBuilder extends
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      * @return The stopSequences.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences();
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
 
     /**
      * optional double temperature = 9;
@@ -12018,15 +12018,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder.class);
     }
 
     private int bitField0_;
@@ -12220,7 +12220,7 @@ public double getPresencePenalty() {
     }
 
     public static final int STOP_SEQUENCES_FIELD_NUMBER = 8;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      * @return Whether the stopSequences field is set.
@@ -12234,15 +12234,15 @@ public boolean hasStopSequences() {
      * @return The stopSequences.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
 
     public static final int TEMPERATURE_FIELD_NUMBER = 9;
@@ -12358,10 +12358,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -12470,44 +12470,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -12515,26 +12515,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -12547,7 +12547,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -12568,21 +12568,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeCohere)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -12621,17 +12621,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohere_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -12639,14 +12639,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -12724,16 +12724,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -13213,9 +13213,9 @@ public Builder clearPresencePenalty() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        * @return Whether the stopSequences field is set.
@@ -13227,9 +13227,9 @@ public boolean hasStopSequences() {
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        * @return The stopSequences.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
         if (stopSequencesBuilder_ == null) {
-          return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+          return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         } else {
           return stopSequencesBuilder_.getMessage();
         }
@@ -13237,7 +13237,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSe
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -13254,7 +13254,7 @@ public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProt
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
       public Builder setStopSequences(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (stopSequencesBuilder_ == null) {
           stopSequences_ = builderForValue.build();
         } else {
@@ -13267,11 +13267,11 @@ public Builder setStopSequences(
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public Builder mergeStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             stopSequences_ != null &&
-            stopSequences_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            stopSequences_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getStopSequencesBuilder().mergeFrom(value);
           } else {
             stopSequences_ = value;
@@ -13301,7 +13301,7 @@ public Builder clearStopSequences() {
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getStopSequencesFieldBuilder().getBuilder();
@@ -13309,23 +13309,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
         if (stopSequencesBuilder_ != null) {
           return stopSequencesBuilder_.getMessageOrBuilder();
         } else {
           return stopSequences_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getStopSequencesFieldBuilder() {
         if (stopSequencesBuilder_ == null) {
           stopSequencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getStopSequences(),
                   getParentForChildren(),
                   isClean());
@@ -13390,12 +13390,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeCohere)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13431,7 +13431,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohere getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohere getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13465,15 +13465,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder.class);
     }
 
     private byte memoizedIsInitialized = -1;
@@ -13509,10 +13509,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) obj;
 
       if (!getUnknownFields().equals(other.getUnknownFields())) return false;
       return true;
@@ -13530,44 +13530,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -13575,26 +13575,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -13607,7 +13607,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -13628,21 +13628,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDummy)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.newBuilder()
       private Builder() {
 
       }
@@ -13661,17 +13661,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummy_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -13679,8 +13679,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDum
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy(this);
         onBuilt();
         return result;
       }
@@ -13719,16 +13719,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy.getDefaultInstance()) return this;
         this.mergeUnknownFields(other.getUnknownFields());
         onChanged();
         return this;
@@ -13787,12 +13787,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDummy)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13828,7 +13828,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummy getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummy getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -13931,15 +13931,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder.class);
     }
 
     private int bitField0_;
@@ -14160,10 +14160,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -14231,44 +14231,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14276,26 +14276,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -14308,7 +14308,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -14329,21 +14329,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeMistral)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.newBuilder()
       private Builder() {
 
       }
@@ -14368,17 +14368,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistral_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -14386,14 +14386,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -14453,16 +14453,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -14844,12 +14844,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeMistral)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14885,7 +14885,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistral getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistral getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -14949,11 +14949,11 @@ public interface GenerativeOllamaOrBuilder extends
      * optional .weaviate.v1.TextArray images = 4;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 5;
@@ -14964,11 +14964,11 @@ public interface GenerativeOllamaOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 5;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeOllama}
@@ -14996,15 +14996,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder.class);
     }
 
     private int bitField0_;
@@ -15122,7 +15122,7 @@ public double getTemperature() {
     }
 
     public static final int IMAGES_FIELD_NUMBER = 4;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 4;
      * @return Whether the images field is set.
@@ -15136,19 +15136,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 5;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 5;
      * @return Whether the imageProperties field is set.
@@ -15162,15 +15162,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -15239,10 +15239,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) obj;
 
       if (hasApiEndpoint() != other.hasApiEndpoint()) return false;
       if (hasApiEndpoint()) {
@@ -15307,44 +15307,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15352,26 +15352,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -15384,7 +15384,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -15405,21 +15405,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeOllama)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -15459,17 +15459,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllama_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -15477,14 +15477,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOll
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -15548,16 +15548,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama.getDefaultInstance()) return this;
         if (other.hasApiEndpoint()) {
           apiEndpoint_ = other.apiEndpoint_;
           bitField0_ |= 0x00000001;
@@ -15847,9 +15847,9 @@ public Builder clearTemperature() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 4;
        * @return Whether the images field is set.
@@ -15861,9 +15861,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 4;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -15871,7 +15871,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 4;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -15888,7 +15888,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 4;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -15901,11 +15901,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 4;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00000008) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -15935,7 +15935,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00000008;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -15943,23 +15943,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -15968,9 +15968,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        * @return Whether the imageProperties field is set.
@@ -15982,9 +15982,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 5;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -15992,7 +15992,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -16009,7 +16009,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -16022,11 +16022,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00000010) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -16056,7 +16056,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00000010;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -16064,23 +16064,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -16105,12 +16105,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeOllama)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16146,7 +16146,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllama getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllama getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -16226,11 +16226,11 @@ public interface GenerativeOpenAIOrBuilder extends
      * optional .weaviate.v1.TextArray stop = 6;
      * @return The stop.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop();
     /**
      * optional .weaviate.v1.TextArray stop = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder();
 
     /**
      * optional double temperature = 7;
@@ -16342,11 +16342,11 @@ public interface GenerativeOpenAIOrBuilder extends
      * optional .weaviate.v1.TextArray images = 14;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 14;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
@@ -16357,11 +16357,11 @@ public interface GenerativeOpenAIOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 15;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeOpenAI}
@@ -16392,15 +16392,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder.class);
     }
 
     private int bitField0_;
@@ -16528,7 +16528,7 @@ public double getPresencePenalty() {
     }
 
     public static final int STOP_FIELD_NUMBER = 6;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stop_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stop_;
     /**
      * optional .weaviate.v1.TextArray stop = 6;
      * @return Whether the stop field is set.
@@ -16542,15 +16542,15 @@ public boolean hasStop() {
      * @return The stop.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop() {
-      return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop() {
+      return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
     }
     /**
      * optional .weaviate.v1.TextArray stop = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
-      return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
+      return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
     }
 
     public static final int TEMPERATURE_FIELD_NUMBER = 7;
@@ -16799,7 +16799,7 @@ public boolean getIsAzure() {
     }
 
     public static final int IMAGES_FIELD_NUMBER = 14;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 14;
      * @return Whether the images field is set.
@@ -16813,19 +16813,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 14;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 15;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      * @return Whether the imageProperties field is set.
@@ -16839,15 +16839,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 15;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -16983,10 +16983,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) obj;
 
       if (hasFrequencyPenalty() != other.hasFrequencyPenalty()) return false;
       if (hasFrequencyPenalty()) {
@@ -17150,44 +17150,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17195,26 +17195,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -17227,7 +17227,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -17248,21 +17248,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeOpenAI)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -17317,17 +17317,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAI_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -17335,14 +17335,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -17448,16 +17448,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI.getDefaultInstance()) return this;
         if (other.hasFrequencyPenalty()) {
           setFrequencyPenalty(other.getFrequencyPenalty());
         }
@@ -17876,9 +17876,9 @@ public Builder clearPresencePenalty() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stop_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stop_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> stopBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> stopBuilder_;
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        * @return Whether the stop field is set.
@@ -17890,9 +17890,9 @@ public boolean hasStop() {
        * optional .weaviate.v1.TextArray stop = 6;
        * @return The stop.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop() {
         if (stopBuilder_ == null) {
-          return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+          return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
         } else {
           return stopBuilder_.getMessage();
         }
@@ -17900,7 +17900,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop()
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        */
-      public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -17917,7 +17917,7 @@ public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Tex
        * optional .weaviate.v1.TextArray stop = 6;
        */
       public Builder setStop(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (stopBuilder_ == null) {
           stop_ = builderForValue.build();
         } else {
@@ -17930,11 +17930,11 @@ public Builder setStop(
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        */
-      public Builder mergeStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopBuilder_ == null) {
           if (((bitField0_ & 0x00000020) != 0) &&
             stop_ != null &&
-            stop_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            stop_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getStopBuilder().mergeFrom(value);
           } else {
             stop_ = value;
@@ -17964,7 +17964,7 @@ public Builder clearStop() {
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getStopBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getStopBuilder() {
         bitField0_ |= 0x00000020;
         onChanged();
         return getStopFieldBuilder().getBuilder();
@@ -17972,23 +17972,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
         if (stopBuilder_ != null) {
           return stopBuilder_.getMessageOrBuilder();
         } else {
           return stop_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray stop = 6;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getStopFieldBuilder() {
         if (stopBuilder_ == null) {
           stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getStop(),
                   getParentForChildren(),
                   isClean());
@@ -18433,9 +18433,9 @@ public Builder clearIsAzure() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 14;
        * @return Whether the images field is set.
@@ -18447,9 +18447,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 14;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -18457,7 +18457,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -18474,7 +18474,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 14;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -18487,11 +18487,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00002000) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -18521,7 +18521,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00002000;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -18529,23 +18529,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 14;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -18554,9 +18554,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        * @return Whether the imageProperties field is set.
@@ -18568,9 +18568,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 15;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -18578,7 +18578,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -18595,7 +18595,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -18608,11 +18608,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00004000) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -18642,7 +18642,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00004000;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -18650,23 +18650,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 15;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -18691,12 +18691,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeOpenAI)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18732,7 +18732,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAI getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -18834,11 +18834,11 @@ public interface GenerativeGoogleOrBuilder extends
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      * @return The stopSequences.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences();
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder();
 
     /**
      * optional string api_endpoint = 9;
@@ -18917,11 +18917,11 @@ public interface GenerativeGoogleOrBuilder extends
      * optional .weaviate.v1.TextArray images = 13;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 13;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 14;
@@ -18932,11 +18932,11 @@ public interface GenerativeGoogleOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 14;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 14;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeGoogle}
@@ -18967,15 +18967,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder.class);
     }
 
     private int bitField0_;
@@ -19141,7 +19141,7 @@ public double getTopP() {
     }
 
     public static final int STOP_SEQUENCES_FIELD_NUMBER = 8;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      * @return Whether the stopSequences field is set.
@@ -19155,15 +19155,15 @@ public boolean hasStopSequences() {
      * @return The stopSequences.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
     /**
      * optional .weaviate.v1.TextArray stop_sequences = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
-      return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
     }
 
     public static final int API_ENDPOINT_FIELD_NUMBER = 9;
@@ -19355,7 +19355,7 @@ public java.lang.String getRegion() {
     }
 
     public static final int IMAGES_FIELD_NUMBER = 13;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 13;
      * @return Whether the images field is set.
@@ -19369,19 +19369,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 13;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 14;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 14;
      * @return Whether the imageProperties field is set.
@@ -19395,15 +19395,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 14;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -19532,10 +19532,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) obj;
 
       if (hasFrequencyPenalty() != other.hasFrequencyPenalty()) return false;
       if (hasFrequencyPenalty()) {
@@ -19689,44 +19689,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -19734,26 +19734,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -19766,7 +19766,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -19787,21 +19787,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogle)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -19855,17 +19855,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogle_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -19873,14 +19873,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -19982,16 +19982,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle.getDefaultInstance()) return this;
         if (other.hasFrequencyPenalty()) {
           setFrequencyPenalty(other.getFrequencyPenalty());
         }
@@ -20482,9 +20482,9 @@ public Builder clearTopP() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stopSequences_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stopSequences_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> stopSequencesBuilder_;
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        * @return Whether the stopSequences field is set.
@@ -20496,9 +20496,9 @@ public boolean hasStopSequences() {
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        * @return The stopSequences.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSequences() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStopSequences() {
         if (stopSequencesBuilder_ == null) {
-          return stopSequences_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+          return stopSequences_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         } else {
           return stopSequencesBuilder_.getMessage();
         }
@@ -20506,7 +20506,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStopSe
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -20523,7 +20523,7 @@ public Builder setStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProt
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
       public Builder setStopSequences(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (stopSequencesBuilder_ == null) {
           stopSequences_ = builderForValue.build();
         } else {
@@ -20536,11 +20536,11 @@ public Builder setStopSequences(
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public Builder mergeStopSequences(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeStopSequences(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopSequencesBuilder_ == null) {
           if (((bitField0_ & 0x00000080) != 0) &&
             stopSequences_ != null &&
-            stopSequences_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            stopSequences_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getStopSequencesBuilder().mergeFrom(value);
           } else {
             stopSequences_ = value;
@@ -20570,7 +20570,7 @@ public Builder clearStopSequences() {
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getStopSequencesBuilder() {
         bitField0_ |= 0x00000080;
         onChanged();
         return getStopSequencesFieldBuilder().getBuilder();
@@ -20578,23 +20578,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopSequencesOrBuilder() {
         if (stopSequencesBuilder_ != null) {
           return stopSequencesBuilder_.getMessageOrBuilder();
         } else {
           return stopSequences_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stopSequences_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray stop_sequences = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getStopSequencesFieldBuilder() {
         if (stopSequencesBuilder_ == null) {
           stopSequencesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getStopSequences(),
                   getParentForChildren(),
                   isClean());
@@ -20919,9 +20919,9 @@ public Builder setRegionBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 13;
        * @return Whether the images field is set.
@@ -20933,9 +20933,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 13;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -20943,7 +20943,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 13;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -20960,7 +20960,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 13;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -20973,11 +20973,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 13;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00001000) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -21007,7 +21007,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 13;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00001000;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -21015,23 +21015,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 13;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 13;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -21040,9 +21040,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        * @return Whether the imageProperties field is set.
@@ -21054,9 +21054,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 14;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -21064,7 +21064,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -21081,7 +21081,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -21094,11 +21094,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00002000) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -21128,7 +21128,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00002000;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -21136,23 +21136,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 14;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -21177,12 +21177,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogle)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -21218,7 +21218,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogle getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -21337,11 +21337,11 @@ public interface GenerativeDatabricksOrBuilder extends
      * optional .weaviate.v1.TextArray stop = 9;
      * @return The stop.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop();
     /**
      * optional .weaviate.v1.TextArray stop = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder();
 
     /**
      * optional double temperature = 10;
@@ -21391,15 +21391,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder.class);
     }
 
     private int bitField0_;
@@ -21612,7 +21612,7 @@ public double getPresencePenalty() {
     }
 
     public static final int STOP_FIELD_NUMBER = 9;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stop_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stop_;
     /**
      * optional .weaviate.v1.TextArray stop = 9;
      * @return Whether the stop field is set.
@@ -21626,15 +21626,15 @@ public boolean hasStop() {
      * @return The stop.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop() {
-      return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop() {
+      return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
     }
     /**
      * optional .weaviate.v1.TextArray stop = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
-      return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
+      return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
     }
 
     public static final int TEMPERATURE_FIELD_NUMBER = 10;
@@ -21783,10 +21783,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) obj;
 
       if (hasEndpoint() != other.hasEndpoint()) return false;
       if (hasEndpoint()) {
@@ -21915,44 +21915,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -21960,26 +21960,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -21992,7 +21992,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -22013,21 +22013,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDatabricks)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -22068,17 +22068,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricks_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -22086,14 +22086,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -22179,16 +22179,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks.getDefaultInstance()) return this;
         if (other.hasEndpoint()) {
           endpoint_ = other.endpoint_;
           bitField0_ |= 0x00000001;
@@ -22724,9 +22724,9 @@ public Builder clearPresencePenalty() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray stop_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray stop_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> stopBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> stopBuilder_;
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        * @return Whether the stop field is set.
@@ -22738,9 +22738,9 @@ public boolean hasStop() {
        * optional .weaviate.v1.TextArray stop = 9;
        * @return The stop.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getStop() {
         if (stopBuilder_ == null) {
-          return stop_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+          return stop_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
         } else {
           return stopBuilder_.getMessage();
         }
@@ -22748,7 +22748,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getStop()
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        */
-      public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -22765,7 +22765,7 @@ public Builder setStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.Tex
        * optional .weaviate.v1.TextArray stop = 9;
        */
       public Builder setStop(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (stopBuilder_ == null) {
           stop_ = builderForValue.build();
         } else {
@@ -22778,11 +22778,11 @@ public Builder setStop(
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        */
-      public Builder mergeStop(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeStop(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (stopBuilder_ == null) {
           if (((bitField0_ & 0x00000100) != 0) &&
             stop_ != null &&
-            stop_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            stop_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getStopBuilder().mergeFrom(value);
           } else {
             stop_ = value;
@@ -22812,7 +22812,7 @@ public Builder clearStop() {
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getStopBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getStopBuilder() {
         bitField0_ |= 0x00000100;
         onChanged();
         return getStopFieldBuilder().getBuilder();
@@ -22820,23 +22820,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getStopOrBuilder() {
         if (stopBuilder_ != null) {
           return stopBuilder_.getMessageOrBuilder();
         } else {
           return stop_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : stop_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray stop = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getStopFieldBuilder() {
         if (stopBuilder_ == null) {
           stopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getStop(),
                   getParentForChildren(),
                   isClean());
@@ -22941,12 +22941,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDatabricks)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -22982,7 +22982,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricks getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -23096,15 +23096,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder.class);
     }
 
     private int bitField0_;
@@ -23351,10 +23351,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -23432,44 +23432,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -23477,26 +23477,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -23509,7 +23509,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -23530,21 +23530,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeFriendliAI)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.newBuilder()
       private Builder() {
 
       }
@@ -23570,17 +23570,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAI_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -23588,14 +23588,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -23659,16 +23659,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -24098,12 +24098,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeFriendliAI)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -24139,7 +24139,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAI getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -24242,15 +24242,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder.class);
     }
 
     private int bitField0_;
@@ -24471,10 +24471,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -24542,44 +24542,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -24587,26 +24587,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -24619,7 +24619,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -24640,21 +24640,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeNvidia)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.newBuilder()
       private Builder() {
 
       }
@@ -24679,17 +24679,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidia_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -24697,14 +24697,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -24764,16 +24764,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -25155,12 +25155,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeNvidia)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -25196,7 +25196,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidia getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -25282,11 +25282,11 @@ public interface GenerativeXAIOrBuilder extends
      * optional .weaviate.v1.TextArray images = 6;
      * @return The images.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages();
     /**
      * optional .weaviate.v1.TextArray images = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray image_properties = 7;
@@ -25297,11 +25297,11 @@ public interface GenerativeXAIOrBuilder extends
      * optional .weaviate.v1.TextArray image_properties = 7;
      * @return The imageProperties.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties();
     /**
      * optional .weaviate.v1.TextArray image_properties = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeXAI}
@@ -25329,15 +25329,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder.class);
     }
 
     private int bitField0_;
@@ -25493,7 +25493,7 @@ public long getMaxTokens() {
     }
 
     public static final int IMAGES_FIELD_NUMBER = 6;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
     /**
      * optional .weaviate.v1.TextArray images = 6;
      * @return Whether the images field is set.
@@ -25507,19 +25507,19 @@ public boolean hasImages() {
      * @return The images.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
     /**
      * optional .weaviate.v1.TextArray images = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
-      return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
     }
 
     public static final int IMAGE_PROPERTIES_FIELD_NUMBER = 7;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
     /**
      * optional .weaviate.v1.TextArray image_properties = 7;
      * @return Whether the imageProperties field is set.
@@ -25533,15 +25533,15 @@ public boolean hasImageProperties() {
      * @return The imageProperties.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
     /**
      * optional .weaviate.v1.TextArray image_properties = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
-      return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -25624,10 +25624,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) obj;
 
       if (hasBaseUrl() != other.hasBaseUrl()) return false;
       if (hasBaseUrl()) {
@@ -25713,44 +25713,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -25758,26 +25758,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -25790,7 +25790,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -25811,21 +25811,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeXAI)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -25867,17 +25867,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAI_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -25885,14 +25885,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -25964,16 +25964,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI.getDefaultInstance()) return this;
         if (other.hasBaseUrl()) {
           baseUrl_ = other.baseUrl_;
           bitField0_ |= 0x00000001;
@@ -26359,9 +26359,9 @@ public Builder clearMaxTokens() {
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray images_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray images_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagesBuilder_;
       /**
        * optional .weaviate.v1.TextArray images = 6;
        * @return Whether the images field is set.
@@ -26373,9 +26373,9 @@ public boolean hasImages() {
        * optional .weaviate.v1.TextArray images = 6;
        * @return The images.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImages() {
         if (imagesBuilder_ == null) {
-          return images_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+          return images_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         } else {
           return imagesBuilder_.getMessage();
         }
@@ -26383,7 +26383,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImages
       /**
        * optional .weaviate.v1.TextArray images = 6;
        */
-      public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -26400,7 +26400,7 @@ public Builder setImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.T
        * optional .weaviate.v1.TextArray images = 6;
        */
       public Builder setImages(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagesBuilder_ == null) {
           images_ = builderForValue.build();
         } else {
@@ -26413,11 +26413,11 @@ public Builder setImages(
       /**
        * optional .weaviate.v1.TextArray images = 6;
        */
-      public Builder mergeImages(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImages(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagesBuilder_ == null) {
           if (((bitField0_ & 0x00000020) != 0) &&
             images_ != null &&
-            images_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            images_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagesBuilder().mergeFrom(value);
           } else {
             images_ = value;
@@ -26447,7 +26447,7 @@ public Builder clearImages() {
       /**
        * optional .weaviate.v1.TextArray images = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagesBuilder() {
         bitField0_ |= 0x00000020;
         onChanged();
         return getImagesFieldBuilder().getBuilder();
@@ -26455,23 +26455,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray images = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagesOrBuilder() {
         if (imagesBuilder_ != null) {
           return imagesBuilder_.getMessageOrBuilder();
         } else {
           return images_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : images_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray images = 6;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagesFieldBuilder() {
         if (imagesBuilder_ == null) {
           imagesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImages(),
                   getParentForChildren(),
                   isClean());
@@ -26480,9 +26480,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder
         return imagesBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray imageProperties_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray imageProperties_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> imagePropertiesBuilder_;
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        * @return Whether the imageProperties field is set.
@@ -26494,9 +26494,9 @@ public boolean hasImageProperties() {
        * optional .weaviate.v1.TextArray image_properties = 7;
        * @return The imageProperties.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageProperties() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getImageProperties() {
         if (imagePropertiesBuilder_ == null) {
-          return imageProperties_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+          return imageProperties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         } else {
           return imagePropertiesBuilder_.getMessage();
         }
@@ -26504,7 +26504,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getImageP
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
-      public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -26521,7 +26521,7 @@ public Builder setImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviatePr
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
       public Builder setImageProperties(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (imagePropertiesBuilder_ == null) {
           imageProperties_ = builderForValue.build();
         } else {
@@ -26534,11 +26534,11 @@ public Builder setImageProperties(
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
-      public Builder mergeImageProperties(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeImageProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (imagePropertiesBuilder_ == null) {
           if (((bitField0_ & 0x00000040) != 0) &&
             imageProperties_ != null &&
-            imageProperties_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            imageProperties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getImagePropertiesBuilder().mergeFrom(value);
           } else {
             imageProperties_ = value;
@@ -26568,7 +26568,7 @@ public Builder clearImageProperties() {
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getImagePropertiesBuilder() {
         bitField0_ |= 0x00000040;
         onChanged();
         return getImagePropertiesFieldBuilder().getBuilder();
@@ -26576,23 +26576,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getImagePropertiesOrBuilder() {
         if (imagePropertiesBuilder_ != null) {
           return imagePropertiesBuilder_.getMessageOrBuilder();
         } else {
           return imageProperties_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : imageProperties_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray image_properties = 7;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getImagePropertiesFieldBuilder() {
         if (imagePropertiesBuilder_ == null) {
           imagePropertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getImageProperties(),
                   getParentForChildren(),
                   isClean());
@@ -26617,12 +26617,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeXAI)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -26658,7 +26658,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAI getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -26677,11 +26677,11 @@ public interface GenerativeAnthropicMetadataOrBuilder extends
      * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage();
     /**
      * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeAnthropicMetadata}
@@ -26707,15 +26707,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -26758,15 +26758,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder.class);
       }
 
       public static final int INPUT_TOKENS_FIELD_NUMBER = 1;
@@ -26838,10 +26838,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage) obj;
 
         if (getInputTokens()
             != other.getInputTokens()) return false;
@@ -26869,44 +26869,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -26914,26 +26914,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -26946,7 +26946,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -26967,21 +26967,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAnthropicMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -27003,17 +27003,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -27021,14 +27021,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           if (((from_bitField0_ & 0x00000001) != 0)) {
             result.inputTokens_ = inputTokens_;
@@ -27072,16 +27072,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance()) return this;
           if (other.getInputTokens() != 0L) {
             setInputTokens(other.getInputTokens());
           }
@@ -27221,12 +27221,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAnthropicMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -27262,7 +27262,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -27270,7 +27270,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage usage_;
     /**
      * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -27284,15 +27284,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -27335,10 +27335,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -27365,44 +27365,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27410,26 +27410,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27442,7 +27442,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -27463,21 +27463,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAnthropicMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -27508,17 +27508,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnthropicMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -27526,14 +27526,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -27579,16 +27579,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -27642,9 +27642,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -27656,9 +27656,9 @@ public boolean hasUsage() {
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -27666,7 +27666,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -27683,7 +27683,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -27696,11 +27696,11 @@ public Builder setUsage(
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -27730,7 +27730,7 @@ public Builder clearUsage() {
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -27738,23 +27738,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -27779,12 +27779,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAnthropicMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -27820,7 +27820,7 @@ public com.google.protobuf.Parser getParserForType(
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -27854,15 +27854,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder.class);
     }
 
     private byte memoizedIsInitialized = -1;
@@ -27898,10 +27898,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) obj;
 
       if (!getUnknownFields().equals(other.getUnknownFields())) return false;
       return true;
@@ -27919,44 +27919,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27964,26 +27964,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -27996,7 +27996,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -28017,21 +28017,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAnyscaleMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.newBuilder()
       private Builder() {
 
       }
@@ -28050,17 +28050,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAnyscaleMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -28068,8 +28068,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAny
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata(this);
         onBuilt();
         return result;
       }
@@ -28108,16 +28108,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance()) return this;
         this.mergeUnknownFields(other.getUnknownFields());
         onChanged();
         return this;
@@ -28176,12 +28176,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAnyscaleMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28217,7 +28217,7 @@ public com.google.protobuf.Parser getParserForType()
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28251,15 +28251,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder.class);
     }
 
     private byte memoizedIsInitialized = -1;
@@ -28295,10 +28295,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) obj;
 
       if (!getUnknownFields().equals(other.getUnknownFields())) return false;
       return true;
@@ -28316,44 +28316,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -28361,26 +28361,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -28393,7 +28393,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -28414,21 +28414,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeAWSMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.newBuilder()
       private Builder() {
 
       }
@@ -28447,17 +28447,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeAWSMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -28465,8 +28465,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata(this);
         onBuilt();
         return result;
       }
@@ -28505,16 +28505,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance()) return this;
         this.mergeUnknownFields(other.getUnknownFields());
         onChanged();
         return this;
@@ -28573,12 +28573,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeAWSMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28614,7 +28614,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -28633,11 +28633,11 @@ public interface GenerativeCohereMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
      * @return The apiVersion.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion();
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder();
 
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
@@ -28648,11 +28648,11 @@ public interface GenerativeCohereMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
      * @return The billedUnits.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits();
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder();
 
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
@@ -28663,11 +28663,11 @@ public interface GenerativeCohereMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
      * @return The tokens.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens();
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder();
 
     /**
      * optional .weaviate.v1.TextArray warnings = 4;
@@ -28678,11 +28678,11 @@ public interface GenerativeCohereMetadataOrBuilder extends
      * optional .weaviate.v1.TextArray warnings = 4;
      * @return The warnings.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getWarnings();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getWarnings();
     /**
      * optional .weaviate.v1.TextArray warnings = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeCohereMetadata}
@@ -28708,15 +28708,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder.class);
     }
 
     public interface ApiVersionOrBuilder extends
@@ -28787,15 +28787,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder.class);
       }
 
       private int bitField0_;
@@ -28937,10 +28937,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion) obj;
 
         if (hasVersion() != other.hasVersion()) return false;
         if (hasVersion()) {
@@ -28987,44 +28987,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -29032,26 +29032,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -29064,7 +29064,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -29085,21 +29085,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeCohereMetadata.ApiVersion)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.newBuilder()
         private Builder() {
 
         }
@@ -29122,17 +29122,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_ApiVersion_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -29140,14 +29140,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -29199,16 +29199,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance()) return this;
           if (other.hasVersion()) {
             version_ = other.version_;
             bitField0_ |= 0x00000001;
@@ -29453,12 +29453,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeCohereMetadata.ApiVersion)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -29494,7 +29494,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -29572,15 +29572,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder.class);
       }
 
       private int bitField0_;
@@ -29721,10 +29721,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits) obj;
 
         if (hasInputTokens() != other.hasInputTokens()) return false;
         if (hasInputTokens()) {
@@ -29786,44 +29786,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -29831,26 +29831,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -29863,7 +29863,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -29884,21 +29884,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeCohereMetadata.BilledUnits)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.newBuilder()
         private Builder() {
 
         }
@@ -29922,17 +29922,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_BilledUnits_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -29940,14 +29940,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -30003,16 +30003,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance()) return this;
           if (other.hasInputTokens()) {
             setInputTokens(other.getInputTokens());
           }
@@ -30264,12 +30264,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeCohereMetadata.BilledUnits)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -30305,7 +30305,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -30361,15 +30361,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder.class);
       }
 
       private int bitField0_;
@@ -30458,10 +30458,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens) obj;
 
         if (hasInputTokens() != other.hasInputTokens()) return false;
         if (hasInputTokens()) {
@@ -30501,44 +30501,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -30546,26 +30546,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -30578,7 +30578,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -30599,21 +30599,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeCohereMetadata.Tokens)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.newBuilder()
         private Builder() {
 
         }
@@ -30635,17 +30635,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_Tokens_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -30653,14 +30653,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -30708,16 +30708,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance()) return this;
           if (other.hasInputTokens()) {
             setInputTokens(other.getInputTokens());
           }
@@ -30873,12 +30873,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeCohereMetadata.Tokens)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -30914,7 +30914,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -30922,7 +30922,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
 
     private int bitField0_;
     public static final int API_VERSION_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion apiVersion_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion apiVersion_;
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
      * @return Whether the apiVersion field is set.
@@ -30936,19 +30936,19 @@ public boolean hasApiVersion() {
      * @return The apiVersion.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion() {
-      return apiVersion_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion() {
+      return apiVersion_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
     }
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder() {
-      return apiVersion_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder() {
+      return apiVersion_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
     }
 
     public static final int BILLED_UNITS_FIELD_NUMBER = 2;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits billedUnits_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits billedUnits_;
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
      * @return Whether the billedUnits field is set.
@@ -30962,19 +30962,19 @@ public boolean hasBilledUnits() {
      * @return The billedUnits.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits() {
-      return billedUnits_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits() {
+      return billedUnits_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
     }
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder() {
-      return billedUnits_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder() {
+      return billedUnits_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
     }
 
     public static final int TOKENS_FIELD_NUMBER = 3;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens tokens_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens tokens_;
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
      * @return Whether the tokens field is set.
@@ -30988,19 +30988,19 @@ public boolean hasTokens() {
      * @return The tokens.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens() {
-      return tokens_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens() {
+      return tokens_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
     }
     /**
      * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder() {
-      return tokens_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder() {
+      return tokens_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
     }
 
     public static final int WARNINGS_FIELD_NUMBER = 4;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray warnings_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray warnings_;
     /**
      * optional .weaviate.v1.TextArray warnings = 4;
      * @return Whether the warnings field is set.
@@ -31014,15 +31014,15 @@ public boolean hasWarnings() {
      * @return The warnings.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getWarnings() {
-      return warnings_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getWarnings() {
+      return warnings_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
     }
     /**
      * optional .weaviate.v1.TextArray warnings = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder() {
-      return warnings_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder() {
+      return warnings_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -31086,10 +31086,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) obj;
 
       if (hasApiVersion() != other.hasApiVersion()) return false;
       if (hasApiVersion()) {
@@ -31143,44 +31143,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -31188,26 +31188,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -31220,7 +31220,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -31241,21 +31241,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeCohereMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -31304,17 +31304,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeCohereMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -31322,14 +31322,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -31393,16 +31393,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance()) return this;
         if (other.hasApiVersion()) {
           mergeApiVersion(other.getApiVersion());
         }
@@ -31486,9 +31486,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion apiVersion_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion apiVersion_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder> apiVersionBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder> apiVersionBuilder_;
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        * @return Whether the apiVersion field is set.
@@ -31500,9 +31500,9 @@ public boolean hasApiVersion() {
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        * @return The apiVersion.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion getApiVersion() {
         if (apiVersionBuilder_ == null) {
-          return apiVersion_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
+          return apiVersion_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
         } else {
           return apiVersionBuilder_.getMessage();
         }
@@ -31510,7 +31510,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
-      public Builder setApiVersion(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion value) {
+      public Builder setApiVersion(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion value) {
         if (apiVersionBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -31527,7 +31527,7 @@ public Builder setApiVersion(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGe
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
       public Builder setApiVersion(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder builderForValue) {
         if (apiVersionBuilder_ == null) {
           apiVersion_ = builderForValue.build();
         } else {
@@ -31540,11 +31540,11 @@ public Builder setApiVersion(
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
-      public Builder mergeApiVersion(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion value) {
+      public Builder mergeApiVersion(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion value) {
         if (apiVersionBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             apiVersion_ != null &&
-            apiVersion_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance()) {
+            apiVersion_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance()) {
             getApiVersionBuilder().mergeFrom(value);
           } else {
             apiVersion_ = value;
@@ -31574,7 +31574,7 @@ public Builder clearApiVersion() {
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder getApiVersionBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder getApiVersionBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getApiVersionFieldBuilder().getBuilder();
@@ -31582,23 +31582,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder getApiVersionOrBuilder() {
         if (apiVersionBuilder_ != null) {
           return apiVersionBuilder_.getMessageOrBuilder();
         } else {
           return apiVersion_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.getDefaultInstance() : apiVersion_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.ApiVersion api_version = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder> 
           getApiVersionFieldBuilder() {
         if (apiVersionBuilder_ == null) {
           apiVersionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersion.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.ApiVersionOrBuilder>(
                   getApiVersion(),
                   getParentForChildren(),
                   isClean());
@@ -31607,9 +31607,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         return apiVersionBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits billedUnits_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits billedUnits_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder> billedUnitsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder> billedUnitsBuilder_;
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        * @return Whether the billedUnits field is set.
@@ -31621,9 +31621,9 @@ public boolean hasBilledUnits() {
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        * @return The billedUnits.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits getBilledUnits() {
         if (billedUnitsBuilder_ == null) {
-          return billedUnits_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
+          return billedUnits_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
         } else {
           return billedUnitsBuilder_.getMessage();
         }
@@ -31631,7 +31631,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
-      public Builder setBilledUnits(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits value) {
+      public Builder setBilledUnits(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits value) {
         if (billedUnitsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -31648,7 +31648,7 @@ public Builder setBilledUnits(io.weaviate.client.grpc.protocol.v1.WeaviateProtoG
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
       public Builder setBilledUnits(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder builderForValue) {
         if (billedUnitsBuilder_ == null) {
           billedUnits_ = builderForValue.build();
         } else {
@@ -31661,11 +31661,11 @@ public Builder setBilledUnits(
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
-      public Builder mergeBilledUnits(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits value) {
+      public Builder mergeBilledUnits(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits value) {
         if (billedUnitsBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0) &&
             billedUnits_ != null &&
-            billedUnits_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance()) {
+            billedUnits_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance()) {
             getBilledUnitsBuilder().mergeFrom(value);
           } else {
             billedUnits_ = value;
@@ -31695,7 +31695,7 @@ public Builder clearBilledUnits() {
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder getBilledUnitsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder getBilledUnitsBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getBilledUnitsFieldBuilder().getBuilder();
@@ -31703,23 +31703,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder getBilledUnitsOrBuilder() {
         if (billedUnitsBuilder_ != null) {
           return billedUnitsBuilder_.getMessageOrBuilder();
         } else {
           return billedUnits_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.getDefaultInstance() : billedUnits_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.BilledUnits billed_units = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder> 
           getBilledUnitsFieldBuilder() {
         if (billedUnitsBuilder_ == null) {
           billedUnitsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnits.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.BilledUnitsOrBuilder>(
                   getBilledUnits(),
                   getParentForChildren(),
                   isClean());
@@ -31728,9 +31728,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         return billedUnitsBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens tokens_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens tokens_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder> tokensBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder> tokensBuilder_;
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        * @return Whether the tokens field is set.
@@ -31742,9 +31742,9 @@ public boolean hasTokens() {
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        * @return The tokens.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens getTokens() {
         if (tokensBuilder_ == null) {
-          return tokens_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
+          return tokens_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
         } else {
           return tokensBuilder_.getMessage();
         }
@@ -31752,7 +31752,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
-      public Builder setTokens(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens value) {
+      public Builder setTokens(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens value) {
         if (tokensBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -31769,7 +31769,7 @@ public Builder setTokens(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
       public Builder setTokens(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder builderForValue) {
         if (tokensBuilder_ == null) {
           tokens_ = builderForValue.build();
         } else {
@@ -31782,11 +31782,11 @@ public Builder setTokens(
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
-      public Builder mergeTokens(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens value) {
+      public Builder mergeTokens(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens value) {
         if (tokensBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0) &&
             tokens_ != null &&
-            tokens_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance()) {
+            tokens_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance()) {
             getTokensBuilder().mergeFrom(value);
           } else {
             tokens_ = value;
@@ -31816,7 +31816,7 @@ public Builder clearTokens() {
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder getTokensBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder getTokensBuilder() {
         bitField0_ |= 0x00000004;
         onChanged();
         return getTokensFieldBuilder().getBuilder();
@@ -31824,23 +31824,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder getTokensOrBuilder() {
         if (tokensBuilder_ != null) {
           return tokensBuilder_.getMessageOrBuilder();
         } else {
           return tokens_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.getDefaultInstance() : tokens_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeCohereMetadata.Tokens tokens = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder> 
           getTokensFieldBuilder() {
         if (tokensBuilder_ == null) {
           tokensBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Tokens.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.TokensOrBuilder>(
                   getTokens(),
                   getParentForChildren(),
                   isClean());
@@ -31849,9 +31849,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
         return tokensBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray warnings_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray warnings_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> warningsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> warningsBuilder_;
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        * @return Whether the warnings field is set.
@@ -31863,9 +31863,9 @@ public boolean hasWarnings() {
        * optional .weaviate.v1.TextArray warnings = 4;
        * @return The warnings.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getWarnings() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray getWarnings() {
         if (warningsBuilder_ == null) {
-          return warnings_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
+          return warnings_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
         } else {
           return warningsBuilder_.getMessage();
         }
@@ -31873,7 +31873,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray getWarnin
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        */
-      public Builder setWarnings(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder setWarnings(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (warningsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -31890,7 +31890,7 @@ public Builder setWarnings(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase
        * optional .weaviate.v1.TextArray warnings = 4;
        */
       public Builder setWarnings(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder builderForValue) {
         if (warningsBuilder_ == null) {
           warnings_ = builderForValue.build();
         } else {
@@ -31903,11 +31903,11 @@ public Builder setWarnings(
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        */
-      public Builder mergeWarnings(io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray value) {
+      public Builder mergeWarnings(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray value) {
         if (warningsBuilder_ == null) {
           if (((bitField0_ & 0x00000008) != 0) &&
             warnings_ != null &&
-            warnings_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance()) {
+            warnings_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance()) {
             getWarningsBuilder().mergeFrom(value);
           } else {
             warnings_ = value;
@@ -31937,7 +31937,7 @@ public Builder clearWarnings() {
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder getWarningsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder getWarningsBuilder() {
         bitField0_ |= 0x00000008;
         onChanged();
         return getWarningsFieldBuilder().getBuilder();
@@ -31945,23 +31945,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder g
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder getWarningsOrBuilder() {
         if (warningsBuilder_ != null) {
           return warningsBuilder_.getMessageOrBuilder();
         } else {
           return warnings_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.getDefaultInstance() : warnings_;
         }
       }
       /**
        * optional .weaviate.v1.TextArray warnings = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder> 
           getWarningsFieldBuilder() {
         if (warningsBuilder_ == null) {
           warningsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArray.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.TextArrayOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArray.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.TextArrayOrBuilder>(
                   getWarnings(),
                   getParentForChildren(),
                   isClean());
@@ -31986,12 +31986,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeCohereMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -32027,7 +32027,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -32061,15 +32061,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder.class);
     }
 
     private byte memoizedIsInitialized = -1;
@@ -32105,10 +32105,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) obj;
 
       if (!getUnknownFields().equals(other.getUnknownFields())) return false;
       return true;
@@ -32126,44 +32126,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -32171,26 +32171,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -32203,7 +32203,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -32224,21 +32224,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDummyMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.newBuilder()
       private Builder() {
 
       }
@@ -32257,17 +32257,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDummyMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -32275,8 +32275,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDum
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata(this);
         onBuilt();
         return result;
       }
@@ -32315,16 +32315,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance()) return this;
         this.mergeUnknownFields(other.getUnknownFields());
         onChanged();
         return this;
@@ -32383,12 +32383,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDummyMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -32424,7 +32424,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -32443,11 +32443,11 @@ public interface GenerativeMistralMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeMistralMetadata}
@@ -32473,15 +32473,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -32545,15 +32545,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -32668,10 +32668,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -32719,44 +32719,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -32764,26 +32764,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -32796,7 +32796,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -32817,21 +32817,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeMistralMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -32854,17 +32854,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -32872,14 +32872,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -32931,16 +32931,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -33144,12 +33144,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeMistralMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -33185,7 +33185,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -33193,7 +33193,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -33207,15 +33207,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -33258,10 +33258,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -33288,44 +33288,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -33333,26 +33333,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -33365,7 +33365,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -33386,21 +33386,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeMistralMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -33431,17 +33431,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMistralMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -33449,14 +33449,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -33502,16 +33502,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -33565,9 +33565,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -33579,9 +33579,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -33589,7 +33589,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -33606,7 +33606,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -33619,11 +33619,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -33653,7 +33653,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -33661,23 +33661,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeMistralMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -33702,12 +33702,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeMistralMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -33743,7 +33743,7 @@ public com.google.protobuf.Parser getParserForType()
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -33777,15 +33777,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder.class);
     }
 
     private byte memoizedIsInitialized = -1;
@@ -33821,10 +33821,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) obj;
 
       if (!getUnknownFields().equals(other.getUnknownFields())) return false;
       return true;
@@ -33842,44 +33842,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -33887,26 +33887,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -33919,7 +33919,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -33940,21 +33940,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeOllamaMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.newBuilder()
       private Builder() {
 
       }
@@ -33973,17 +33973,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOllamaMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -33991,8 +33991,8 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOll
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata(this);
         onBuilt();
         return result;
       }
@@ -34031,16 +34031,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance()) return this;
         this.mergeUnknownFields(other.getUnknownFields());
         onChanged();
         return this;
@@ -34099,12 +34099,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeOllamaMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -34140,7 +34140,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -34159,11 +34159,11 @@ public interface GenerativeOpenAIMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeOpenAIMetadata}
@@ -34189,15 +34189,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -34261,15 +34261,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -34384,10 +34384,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -34435,44 +34435,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -34480,26 +34480,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -34512,7 +34512,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -34533,21 +34533,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeOpenAIMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -34570,17 +34570,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -34588,14 +34588,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -34647,16 +34647,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -34860,12 +34860,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeOpenAIMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -34901,7 +34901,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -34909,7 +34909,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -34923,15 +34923,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -34974,10 +34974,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -35004,44 +35004,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -35049,26 +35049,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -35081,7 +35081,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -35102,21 +35102,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeOpenAIMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -35147,17 +35147,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeOpenAIMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -35165,14 +35165,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -35218,16 +35218,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -35281,9 +35281,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -35295,9 +35295,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -35305,7 +35305,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -35322,7 +35322,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -35335,11 +35335,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -35369,7 +35369,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -35377,23 +35377,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeOpenAIMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -35418,12 +35418,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeOpenAIMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -35459,7 +35459,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -35478,11 +35478,11 @@ public interface GenerativeGoogleMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
      * @return The metadata.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata();
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder();
 
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
@@ -35493,11 +35493,11 @@ public interface GenerativeGoogleMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
      * @return The usageMetadata.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata();
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeGoogleMetadata}
@@ -35523,15 +35523,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder.class);
     }
 
     public interface TokenCountOrBuilder extends
@@ -35584,15 +35584,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder.class);
       }
 
       private int bitField0_;
@@ -35681,10 +35681,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount) obj;
 
         if (hasTotalBillableCharacters() != other.hasTotalBillableCharacters()) return false;
         if (hasTotalBillableCharacters()) {
@@ -35722,44 +35722,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -35767,26 +35767,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -35799,7 +35799,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -35820,21 +35820,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogleMetadata.TokenCount)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.newBuilder()
         private Builder() {
 
         }
@@ -35856,17 +35856,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenCount_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -35874,14 +35874,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -35929,16 +35929,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) return this;
           if (other.hasTotalBillableCharacters()) {
             setTotalBillableCharacters(other.getTotalBillableCharacters());
           }
@@ -36094,12 +36094,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogleMetadata.TokenCount)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -36135,7 +36135,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -36154,11 +36154,11 @@ public interface TokenMetadataOrBuilder extends
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
        * @return The inputTokenCount.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount();
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder();
 
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
@@ -36169,11 +36169,11 @@ public interface TokenMetadataOrBuilder extends
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
        * @return The outputTokenCount.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount();
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder();
     }
     /**
      * Protobuf type {@code weaviate.v1.GenerativeGoogleMetadata.TokenMetadata}
@@ -36199,20 +36199,20 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder.class);
       }
 
       private int bitField0_;
       public static final int INPUT_TOKEN_COUNT_FIELD_NUMBER = 1;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount inputTokenCount_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount inputTokenCount_;
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
        * @return Whether the inputTokenCount field is set.
@@ -36226,19 +36226,19 @@ public boolean hasInputTokenCount() {
        * @return The inputTokenCount.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount() {
-        return inputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount() {
+        return inputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
       }
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder() {
-        return inputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder() {
+        return inputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
       }
 
       public static final int OUTPUT_TOKEN_COUNT_FIELD_NUMBER = 2;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount outputTokenCount_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount outputTokenCount_;
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
        * @return Whether the outputTokenCount field is set.
@@ -36252,15 +36252,15 @@ public boolean hasOutputTokenCount() {
        * @return The outputTokenCount.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount() {
-        return outputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount() {
+        return outputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
       }
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder() {
-        return outputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder() {
+        return outputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
       }
 
       private byte memoizedIsInitialized = -1;
@@ -36310,10 +36310,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata) obj;
 
         if (hasInputTokenCount() != other.hasInputTokenCount()) return false;
         if (hasInputTokenCount()) {
@@ -36349,44 +36349,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -36394,26 +36394,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -36426,7 +36426,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -36447,21 +36447,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogleMetadata.TokenMetadata)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.newBuilder()
         private Builder() {
           maybeForceBuilderInitialization();
         }
@@ -36498,17 +36498,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_TokenMetadata_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -36516,14 +36516,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -36575,16 +36575,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance()) return this;
           if (other.hasInputTokenCount()) {
             mergeInputTokenCount(other.getInputTokenCount());
           }
@@ -36648,9 +36648,9 @@ public Builder mergeFrom(
         }
         private int bitField0_;
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount inputTokenCount_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount inputTokenCount_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> inputTokenCountBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> inputTokenCountBuilder_;
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          * @return Whether the inputTokenCount field is set.
@@ -36662,9 +36662,9 @@ public boolean hasInputTokenCount() {
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          * @return The inputTokenCount.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getInputTokenCount() {
           if (inputTokenCountBuilder_ == null) {
-            return inputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
+            return inputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
           } else {
             return inputTokenCountBuilder_.getMessage();
           }
@@ -36672,7 +36672,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
-        public Builder setInputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
+        public Builder setInputTokenCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
           if (inputTokenCountBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -36689,7 +36689,7 @@ public Builder setInputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviatePr
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
         public Builder setInputTokenCount(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder builderForValue) {
           if (inputTokenCountBuilder_ == null) {
             inputTokenCount_ = builderForValue.build();
           } else {
@@ -36702,11 +36702,11 @@ public Builder setInputTokenCount(
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
-        public Builder mergeInputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
+        public Builder mergeInputTokenCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
           if (inputTokenCountBuilder_ == null) {
             if (((bitField0_ & 0x00000001) != 0) &&
               inputTokenCount_ != null &&
-              inputTokenCount_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) {
+              inputTokenCount_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) {
               getInputTokenCountBuilder().mergeFrom(value);
             } else {
               inputTokenCount_ = value;
@@ -36736,7 +36736,7 @@ public Builder clearInputTokenCount() {
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder getInputTokenCountBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder getInputTokenCountBuilder() {
           bitField0_ |= 0x00000001;
           onChanged();
           return getInputTokenCountFieldBuilder().getBuilder();
@@ -36744,23 +36744,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getInputTokenCountOrBuilder() {
           if (inputTokenCountBuilder_ != null) {
             return inputTokenCountBuilder_.getMessageOrBuilder();
           } else {
             return inputTokenCount_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : inputTokenCount_;
           }
         }
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount input_token_count = 1;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> 
             getInputTokenCountFieldBuilder() {
           if (inputTokenCountBuilder_ == null) {
             inputTokenCountBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder>(
                     getInputTokenCount(),
                     getParentForChildren(),
                     isClean());
@@ -36769,9 +36769,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
           return inputTokenCountBuilder_;
         }
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount outputTokenCount_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount outputTokenCount_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> outputTokenCountBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> outputTokenCountBuilder_;
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          * @return Whether the outputTokenCount field is set.
@@ -36783,9 +36783,9 @@ public boolean hasOutputTokenCount() {
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          * @return The outputTokenCount.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount getOutputTokenCount() {
           if (outputTokenCountBuilder_ == null) {
-            return outputTokenCount_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
+            return outputTokenCount_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
           } else {
             return outputTokenCountBuilder_.getMessage();
           }
@@ -36793,7 +36793,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
-        public Builder setOutputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
+        public Builder setOutputTokenCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
           if (outputTokenCountBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -36810,7 +36810,7 @@ public Builder setOutputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviateP
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
         public Builder setOutputTokenCount(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder builderForValue) {
           if (outputTokenCountBuilder_ == null) {
             outputTokenCount_ = builderForValue.build();
           } else {
@@ -36823,11 +36823,11 @@ public Builder setOutputTokenCount(
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
-        public Builder mergeOutputTokenCount(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
+        public Builder mergeOutputTokenCount(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount value) {
           if (outputTokenCountBuilder_ == null) {
             if (((bitField0_ & 0x00000002) != 0) &&
               outputTokenCount_ != null &&
-              outputTokenCount_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) {
+              outputTokenCount_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance()) {
               getOutputTokenCountBuilder().mergeFrom(value);
             } else {
               outputTokenCount_ = value;
@@ -36857,7 +36857,7 @@ public Builder clearOutputTokenCount() {
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder getOutputTokenCountBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder getOutputTokenCountBuilder() {
           bitField0_ |= 0x00000002;
           onChanged();
           return getOutputTokenCountFieldBuilder().getBuilder();
@@ -36865,23 +36865,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder getOutputTokenCountOrBuilder() {
           if (outputTokenCountBuilder_ != null) {
             return outputTokenCountBuilder_.getMessageOrBuilder();
           } else {
             return outputTokenCount_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.getDefaultInstance() : outputTokenCount_;
           }
         }
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenCount output_token_count = 2;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder> 
             getOutputTokenCountFieldBuilder() {
           if (outputTokenCountBuilder_ == null) {
             outputTokenCountBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCount.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenCountOrBuilder>(
                     getOutputTokenCount(),
                     getParentForChildren(),
                     isClean());
@@ -36906,12 +36906,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogleMetadata.TokenMetadata)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -36947,7 +36947,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -36966,11 +36966,11 @@ public interface MetadataOrBuilder extends
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
        * @return The tokenMetadata.
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata();
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
        */
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder();
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder();
     }
     /**
      * Protobuf type {@code weaviate.v1.GenerativeGoogleMetadata.Metadata}
@@ -36996,20 +36996,20 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder.class);
       }
 
       private int bitField0_;
       public static final int TOKEN_METADATA_FIELD_NUMBER = 1;
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata tokenMetadata_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata tokenMetadata_;
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
        * @return Whether the tokenMetadata field is set.
@@ -37023,15 +37023,15 @@ public boolean hasTokenMetadata() {
        * @return The tokenMetadata.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata() {
-        return tokenMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata() {
+        return tokenMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
       }
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder() {
-        return tokenMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder() {
+        return tokenMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
       }
 
       private byte memoizedIsInitialized = -1;
@@ -37074,10 +37074,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata) obj;
 
         if (hasTokenMetadata() != other.hasTokenMetadata()) return false;
         if (hasTokenMetadata()) {
@@ -37104,44 +37104,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -37149,26 +37149,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -37181,7 +37181,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -37202,21 +37202,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogleMetadata.Metadata)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.newBuilder()
         private Builder() {
           maybeForceBuilderInitialization();
         }
@@ -37247,17 +37247,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_Metadata_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -37265,14 +37265,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -37318,16 +37318,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance()) return this;
           if (other.hasTokenMetadata()) {
             mergeTokenMetadata(other.getTokenMetadata());
           }
@@ -37381,9 +37381,9 @@ public Builder mergeFrom(
         }
         private int bitField0_;
 
-        private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata tokenMetadata_;
+        private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata tokenMetadata_;
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder> tokenMetadataBuilder_;
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder> tokenMetadataBuilder_;
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          * @return Whether the tokenMetadata field is set.
@@ -37395,9 +37395,9 @@ public boolean hasTokenMetadata() {
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          * @return The tokenMetadata.
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata getTokenMetadata() {
           if (tokenMetadataBuilder_ == null) {
-            return tokenMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
+            return tokenMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
           } else {
             return tokenMetadataBuilder_.getMessage();
           }
@@ -37405,7 +37405,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
-        public Builder setTokenMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata value) {
+        public Builder setTokenMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata value) {
           if (tokenMetadataBuilder_ == null) {
             if (value == null) {
               throw new NullPointerException();
@@ -37422,7 +37422,7 @@ public Builder setTokenMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProt
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
         public Builder setTokenMetadata(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder builderForValue) {
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder builderForValue) {
           if (tokenMetadataBuilder_ == null) {
             tokenMetadata_ = builderForValue.build();
           } else {
@@ -37435,11 +37435,11 @@ public Builder setTokenMetadata(
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
-        public Builder mergeTokenMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata value) {
+        public Builder mergeTokenMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata value) {
           if (tokenMetadataBuilder_ == null) {
             if (((bitField0_ & 0x00000001) != 0) &&
               tokenMetadata_ != null &&
-              tokenMetadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance()) {
+              tokenMetadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance()) {
               getTokenMetadataBuilder().mergeFrom(value);
             } else {
               tokenMetadata_ = value;
@@ -37469,7 +37469,7 @@ public Builder clearTokenMetadata() {
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder getTokenMetadataBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder getTokenMetadataBuilder() {
           bitField0_ |= 0x00000001;
           onChanged();
           return getTokenMetadataFieldBuilder().getBuilder();
@@ -37477,23 +37477,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder() {
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder getTokenMetadataOrBuilder() {
           if (tokenMetadataBuilder_ != null) {
             return tokenMetadataBuilder_.getMessageOrBuilder();
           } else {
             return tokenMetadata_ == null ?
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.getDefaultInstance() : tokenMetadata_;
           }
         }
         /**
          * optional .weaviate.v1.GenerativeGoogleMetadata.TokenMetadata token_metadata = 1;
          */
         private com.google.protobuf.SingleFieldBuilderV3<
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder> 
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder> 
             getTokenMetadataFieldBuilder() {
           if (tokenMetadataBuilder_ == null) {
             tokenMetadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder>(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.TokenMetadataOrBuilder>(
                     getTokenMetadata(),
                     getParentForChildren(),
                     isClean());
@@ -37518,12 +37518,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogleMetadata.Metadata)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -37559,7 +37559,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -37626,15 +37626,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder.class);
       }
 
       private int bitField0_;
@@ -37749,10 +37749,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata) obj;
 
         if (hasPromptTokenCount() != other.hasPromptTokenCount()) return false;
         if (hasPromptTokenCount()) {
@@ -37800,44 +37800,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -37845,26 +37845,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -37877,7 +37877,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -37898,21 +37898,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogleMetadata.UsageMetadata)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.newBuilder()
         private Builder() {
 
         }
@@ -37935,17 +37935,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_UsageMetadata_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -37953,14 +37953,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -38012,16 +38012,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance()) return this;
           if (other.hasPromptTokenCount()) {
             setPromptTokenCount(other.getPromptTokenCount());
           }
@@ -38225,12 +38225,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogleMetadata.UsageMetadata)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -38266,7 +38266,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -38274,7 +38274,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
 
     private int bitField0_;
     public static final int METADATA_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata metadata_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata metadata_;
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
      * @return Whether the metadata field is set.
@@ -38288,19 +38288,19 @@ public boolean hasMetadata() {
      * @return The metadata.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata() {
-      return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata() {
+      return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
     }
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder() {
-      return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder() {
+      return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
     }
 
     public static final int USAGE_METADATA_FIELD_NUMBER = 2;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata usageMetadata_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata usageMetadata_;
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
      * @return Whether the usageMetadata field is set.
@@ -38314,15 +38314,15 @@ public boolean hasUsageMetadata() {
      * @return The usageMetadata.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata() {
-      return usageMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata() {
+      return usageMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
     }
     /**
      * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder() {
-      return usageMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder() {
+      return usageMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -38372,10 +38372,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) obj;
 
       if (hasMetadata() != other.hasMetadata()) return false;
       if (hasMetadata()) {
@@ -38411,44 +38411,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -38456,26 +38456,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -38488,7 +38488,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -38509,21 +38509,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeGoogleMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -38560,17 +38560,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeGoogleMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -38578,14 +38578,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -38637,16 +38637,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance()) return this;
         if (other.hasMetadata()) {
           mergeMetadata(other.getMetadata());
         }
@@ -38710,9 +38710,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata metadata_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata metadata_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder> metadataBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder> metadataBuilder_;
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        * @return Whether the metadata field is set.
@@ -38724,9 +38724,9 @@ public boolean hasMetadata() {
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        * @return The metadata.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata getMetadata() {
         if (metadataBuilder_ == null) {
-          return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
+          return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
         } else {
           return metadataBuilder_.getMessage();
         }
@@ -38734,7 +38734,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
-      public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata value) {
+      public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata value) {
         if (metadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -38751,7 +38751,7 @@ public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGene
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
       public Builder setMetadata(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder builderForValue) {
         if (metadataBuilder_ == null) {
           metadata_ = builderForValue.build();
         } else {
@@ -38764,11 +38764,11 @@ public Builder setMetadata(
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
-      public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata value) {
+      public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata value) {
         if (metadataBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             metadata_ != null &&
-            metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance()) {
+            metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance()) {
             getMetadataBuilder().mergeFrom(value);
           } else {
             metadata_ = value;
@@ -38798,7 +38798,7 @@ public Builder clearMetadata() {
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder getMetadataBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder getMetadataBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getMetadataFieldBuilder().getBuilder();
@@ -38806,23 +38806,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder getMetadataOrBuilder() {
         if (metadataBuilder_ != null) {
           return metadataBuilder_.getMessageOrBuilder();
         } else {
           return metadata_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.getDefaultInstance() : metadata_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.Metadata metadata = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder> 
           getMetadataFieldBuilder() {
         if (metadataBuilder_ == null) {
           metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Metadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.MetadataOrBuilder>(
                   getMetadata(),
                   getParentForChildren(),
                   isClean());
@@ -38831,9 +38831,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
         return metadataBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata usageMetadata_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata usageMetadata_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder> usageMetadataBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder> usageMetadataBuilder_;
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        * @return Whether the usageMetadata field is set.
@@ -38845,9 +38845,9 @@ public boolean hasUsageMetadata() {
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        * @return The usageMetadata.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata getUsageMetadata() {
         if (usageMetadataBuilder_ == null) {
-          return usageMetadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
+          return usageMetadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
         } else {
           return usageMetadataBuilder_.getMessage();
         }
@@ -38855,7 +38855,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
-      public Builder setUsageMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata value) {
+      public Builder setUsageMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata value) {
         if (usageMetadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -38872,7 +38872,7 @@ public Builder setUsageMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProt
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
       public Builder setUsageMetadata(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder builderForValue) {
         if (usageMetadataBuilder_ == null) {
           usageMetadata_ = builderForValue.build();
         } else {
@@ -38885,11 +38885,11 @@ public Builder setUsageMetadata(
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
-      public Builder mergeUsageMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata value) {
+      public Builder mergeUsageMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata value) {
         if (usageMetadataBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0) &&
             usageMetadata_ != null &&
-            usageMetadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance()) {
+            usageMetadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance()) {
             getUsageMetadataBuilder().mergeFrom(value);
           } else {
             usageMetadata_ = value;
@@ -38919,7 +38919,7 @@ public Builder clearUsageMetadata() {
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder getUsageMetadataBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder getUsageMetadataBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getUsageMetadataFieldBuilder().getBuilder();
@@ -38927,23 +38927,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder getUsageMetadataOrBuilder() {
         if (usageMetadataBuilder_ != null) {
           return usageMetadataBuilder_.getMessageOrBuilder();
         } else {
           return usageMetadata_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.getDefaultInstance() : usageMetadata_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeGoogleMetadata.UsageMetadata usage_metadata = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder> 
           getUsageMetadataFieldBuilder() {
         if (usageMetadataBuilder_ == null) {
           usageMetadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.UsageMetadataOrBuilder>(
                   getUsageMetadata(),
                   getParentForChildren(),
                   isClean());
@@ -38968,12 +38968,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeGoogleMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -39009,7 +39009,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -39028,11 +39028,11 @@ public interface GenerativeDatabricksMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeDatabricksMetadata}
@@ -39058,15 +39058,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -39130,15 +39130,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -39253,10 +39253,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -39304,44 +39304,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -39349,26 +39349,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -39381,7 +39381,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -39402,21 +39402,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDatabricksMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -39439,17 +39439,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -39457,14 +39457,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -39516,16 +39516,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -39729,12 +39729,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDatabricksMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -39770,7 +39770,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -39778,7 +39778,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -39792,15 +39792,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -39843,10 +39843,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -39873,44 +39873,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -39918,26 +39918,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -39950,7 +39950,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -39971,21 +39971,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDatabricksMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -40016,17 +40016,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDatabricksMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -40034,14 +40034,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -40087,16 +40087,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -40150,9 +40150,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -40164,9 +40164,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -40174,7 +40174,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -40191,7 +40191,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -40204,11 +40204,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -40238,7 +40238,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -40246,23 +40246,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeDatabricksMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -40287,12 +40287,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDatabricksMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -40328,7 +40328,7 @@ public com.google.protobuf.Parser getParserForType
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -40347,11 +40347,11 @@ public interface GenerativeFriendliAIMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeFriendliAIMetadata}
@@ -40377,15 +40377,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -40449,15 +40449,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -40572,10 +40572,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -40623,44 +40623,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -40668,26 +40668,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -40700,7 +40700,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -40721,21 +40721,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeFriendliAIMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -40758,17 +40758,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -40776,14 +40776,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -40835,16 +40835,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -41048,12 +41048,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeFriendliAIMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -41089,7 +41089,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -41097,7 +41097,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -41111,15 +41111,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -41162,10 +41162,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -41192,44 +41192,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -41237,26 +41237,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -41269,7 +41269,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -41290,21 +41290,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeFriendliAIMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -41335,17 +41335,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeFriendliAIMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -41353,14 +41353,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -41406,16 +41406,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -41469,9 +41469,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -41483,9 +41483,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -41493,7 +41493,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -41510,7 +41510,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -41523,11 +41523,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -41557,7 +41557,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -41565,23 +41565,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeFriendliAIMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -41606,12 +41606,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeFriendliAIMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -41647,7 +41647,7 @@ public com.google.protobuf.Parser getParserForType
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -41666,11 +41666,11 @@ public interface GenerativeNvidiaMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeNvidiaMetadata}
@@ -41696,15 +41696,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -41768,15 +41768,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -41891,10 +41891,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -41942,44 +41942,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -41987,26 +41987,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -42019,7 +42019,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -42040,21 +42040,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeNvidiaMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -42077,17 +42077,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -42095,14 +42095,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -42154,16 +42154,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -42367,12 +42367,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeNvidiaMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -42408,7 +42408,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -42416,7 +42416,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -42430,15 +42430,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -42481,10 +42481,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -42511,44 +42511,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -42556,26 +42556,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -42588,7 +42588,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -42609,21 +42609,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeNvidiaMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -42654,17 +42654,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeNvidiaMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -42672,14 +42672,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -42725,16 +42725,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -42788,9 +42788,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -42802,9 +42802,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -42812,7 +42812,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -42829,7 +42829,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -42842,11 +42842,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -42876,7 +42876,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -42884,23 +42884,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeNvidiaMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -42925,12 +42925,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeNvidiaMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -42966,7 +42966,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -42985,11 +42985,11 @@ public interface GenerativeXAIMetadataOrBuilder extends
      * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
      * @return The usage.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage();
     /**
      * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeXAIMetadata}
@@ -43015,15 +43015,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder.class);
     }
 
     public interface UsageOrBuilder extends
@@ -43087,15 +43087,15 @@ protected java.lang.Object newInstance(
 
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder.class);
       }
 
       private int bitField0_;
@@ -43210,10 +43210,10 @@ public boolean equals(final java.lang.Object obj) {
         if (obj == this) {
          return true;
         }
-        if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage)) {
+        if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage)) {
           return super.equals(obj);
         }
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage) obj;
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage) obj;
 
         if (hasPromptTokens() != other.hasPromptTokens()) return false;
         if (hasPromptTokens()) {
@@ -43261,44 +43261,44 @@ public int hashCode() {
         return hash;
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           java.nio.ByteBuffer data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           com.google.protobuf.ByteString data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(byte[] data)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(byte[] data)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           byte[] data,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws com.google.protobuf.InvalidProtocolBufferException {
         return PARSER.parseFrom(data, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -43306,26 +43306,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
             .parseWithIOException(PARSER, input, extensionRegistry);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseDelimitedFrom(java.io.InputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input);
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseDelimitedFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseDelimitedFrom(
           java.io.InputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input)
           throws java.io.IOException {
         return com.google.protobuf.GeneratedMessageV3
             .parseWithIOException(PARSER, input);
       }
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage parseFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
           throws java.io.IOException {
@@ -43338,7 +43338,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
       public static Builder newBuilder() {
         return DEFAULT_INSTANCE.toBuilder();
       }
-      public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage prototype) {
+      public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage prototype) {
         return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
       }
       @java.lang.Override
@@ -43359,21 +43359,21 @@ protected Builder newBuilderForType(
       public static final class Builder extends
           com.google.protobuf.GeneratedMessageV3.Builder implements
           // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeXAIMetadata.Usage)
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder {
         public static final com.google.protobuf.Descriptors.Descriptor
             getDescriptor() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
         protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
             internalGetFieldAccessorTable() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_fieldAccessorTable
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_fieldAccessorTable
               .ensureFieldAccessorsInitialized(
-                  io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder.class);
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder.class);
         }
 
-        // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.newBuilder()
+        // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.newBuilder()
         private Builder() {
 
         }
@@ -43396,17 +43396,17 @@ public Builder clear() {
         @java.lang.Override
         public com.google.protobuf.Descriptors.Descriptor
             getDescriptorForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_Usage_descriptor;
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstanceForType() {
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstanceForType() {
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance();
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage build() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result = buildPartial();
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage build() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result = buildPartial();
           if (!result.isInitialized()) {
             throw newUninitializedMessageException(result);
           }
@@ -43414,14 +43414,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
         }
 
         @java.lang.Override
-        public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage buildPartial() {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage(this);
+        public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage buildPartial() {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage(this);
           if (bitField0_ != 0) { buildPartial0(result); }
           onBuilt();
           return result;
         }
 
-        private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result) {
+        private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage result) {
           int from_bitField0_ = bitField0_;
           int to_bitField0_ = 0;
           if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -43473,16 +43473,16 @@ public Builder addRepeatedField(
         }
         @java.lang.Override
         public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage) {
-            return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage)other);
+          if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage) {
+            return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage)other);
           } else {
             super.mergeFrom(other);
             return this;
           }
         }
 
-        public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage other) {
-          if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance()) return this;
+        public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage other) {
+          if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance()) return this;
           if (other.hasPromptTokens()) {
             setPromptTokens(other.getPromptTokens());
           }
@@ -43686,12 +43686,12 @@ public final Builder mergeUnknownFields(
       }
 
       // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeXAIMetadata.Usage)
-      private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage DEFAULT_INSTANCE;
+      private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage DEFAULT_INSTANCE;
       static {
-        DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage();
+        DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage();
       }
 
-      public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstance() {
+      public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstance() {
         return DEFAULT_INSTANCE;
       }
 
@@ -43727,7 +43727,7 @@ public com.google.protobuf.Parser getParserForType() {
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstanceForType() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getDefaultInstanceForType() {
         return DEFAULT_INSTANCE;
       }
 
@@ -43735,7 +43735,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
 
     private int bitField0_;
     public static final int USAGE_FIELD_NUMBER = 1;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage usage_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage usage_;
     /**
      * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
      * @return Whether the usage field is set.
@@ -43749,15 +43749,15 @@ public boolean hasUsage() {
      * @return The usage.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
     }
     /**
      * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder() {
-      return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -43800,10 +43800,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) obj;
 
       if (hasUsage() != other.hasUsage()) return false;
       if (hasUsage()) {
@@ -43830,44 +43830,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -43875,26 +43875,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -43907,7 +43907,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -43928,21 +43928,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeXAIMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -43973,17 +43973,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeXAIMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -43991,14 +43991,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -44044,16 +44044,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance()) return this;
         if (other.hasUsage()) {
           mergeUsage(other.getUsage());
         }
@@ -44107,9 +44107,9 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage usage_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage usage_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder> usageBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder> usageBuilder_;
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        * @return Whether the usage field is set.
@@ -44121,9 +44121,9 @@ public boolean hasUsage() {
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        * @return The usage.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage getUsage() {
         if (usageBuilder_ == null) {
-          return usage_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
+          return usage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
         } else {
           return usageBuilder_.getMessage();
         }
@@ -44131,7 +44131,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
-      public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage value) {
+      public Builder setUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -44148,7 +44148,7 @@ public Builder setUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
       public Builder setUsage(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder builderForValue) {
         if (usageBuilder_ == null) {
           usage_ = builderForValue.build();
         } else {
@@ -44161,11 +44161,11 @@ public Builder setUsage(
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
-      public Builder mergeUsage(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage value) {
+      public Builder mergeUsage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage value) {
         if (usageBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0) &&
             usage_ != null &&
-            usage_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance()) {
+            usage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance()) {
             getUsageBuilder().mergeFrom(value);
           } else {
             usage_ = value;
@@ -44195,7 +44195,7 @@ public Builder clearUsage() {
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder getUsageBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder getUsageBuilder() {
         bitField0_ |= 0x00000001;
         onChanged();
         return getUsageFieldBuilder().getBuilder();
@@ -44203,23 +44203,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAI
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder getUsageOrBuilder() {
         if (usageBuilder_ != null) {
           return usageBuilder_.getMessageOrBuilder();
         } else {
           return usage_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.getDefaultInstance() : usage_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeXAIMetadata.Usage usage = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder> 
           getUsageFieldBuilder() {
         if (usageBuilder_ == null) {
           usageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Usage.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.UsageOrBuilder>(
                   getUsage(),
                   getParentForChildren(),
                   isClean());
@@ -44244,12 +44244,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeXAIMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -44285,7 +44285,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -44304,11 +44304,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
      * @return The anthropic.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic();
     /**
      * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
@@ -44319,11 +44319,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
      * @return The anyscale.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale();
     /**
      * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeAWSMetadata aws = 3;
@@ -44334,11 +44334,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeAWSMetadata aws = 3;
      * @return The aws.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getAws();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getAws();
     /**
      * .weaviate.v1.GenerativeAWSMetadata aws = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
@@ -44349,11 +44349,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
      * @return The cohere.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere();
     /**
      * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
@@ -44364,11 +44364,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
      * @return The dummy.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy();
     /**
      * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
@@ -44379,11 +44379,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
      * @return The mistral.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral();
     /**
      * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
@@ -44394,11 +44394,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
      * @return The ollama.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama();
     /**
      * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
@@ -44409,11 +44409,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
      * @return The openai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai();
     /**
      * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeGoogleMetadata google = 9;
@@ -44424,11 +44424,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeGoogleMetadata google = 9;
      * @return The google.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle();
     /**
      * .weaviate.v1.GenerativeGoogleMetadata google = 9;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
@@ -44439,11 +44439,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
      * @return The databricks.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks();
     /**
      * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
@@ -44454,11 +44454,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
      * @return The friendliai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai();
     /**
      * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
@@ -44469,11 +44469,11 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
      * @return The nvidia.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia();
     /**
      * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder();
 
     /**
      * .weaviate.v1.GenerativeXAIMetadata xai = 13;
@@ -44484,13 +44484,13 @@ public interface GenerativeMetadataOrBuilder extends
      * .weaviate.v1.GenerativeXAIMetadata xai = 13;
      * @return The xai.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getXai();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getXai();
     /**
      * .weaviate.v1.GenerativeXAIMetadata xai = 13;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder();
 
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.KindCase getKindCase();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.KindCase getKindCase();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeMetadata}
@@ -44516,15 +44516,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder.class);
     }
 
     private int kindCase_ = 0;
@@ -44605,21 +44605,21 @@ public boolean hasAnthropic() {
      * @return The anthropic.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic() {
       if (kindCase_ == 1) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder() {
       if (kindCase_ == 1) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
     }
 
     public static final int ANYSCALE_FIELD_NUMBER = 2;
@@ -44636,21 +44636,21 @@ public boolean hasAnyscale() {
      * @return The anyscale.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale() {
       if (kindCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder() {
       if (kindCase_ == 2) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
     }
 
     public static final int AWS_FIELD_NUMBER = 3;
@@ -44667,21 +44667,21 @@ public boolean hasAws() {
      * @return The aws.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getAws() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getAws() {
       if (kindCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeAWSMetadata aws = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder() {
       if (kindCase_ == 3) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
     }
 
     public static final int COHERE_FIELD_NUMBER = 4;
@@ -44698,21 +44698,21 @@ public boolean hasCohere() {
      * @return The cohere.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere() {
       if (kindCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder() {
       if (kindCase_ == 4) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
     }
 
     public static final int DUMMY_FIELD_NUMBER = 5;
@@ -44729,21 +44729,21 @@ public boolean hasDummy() {
      * @return The dummy.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy() {
       if (kindCase_ == 5) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder() {
       if (kindCase_ == 5) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
     }
 
     public static final int MISTRAL_FIELD_NUMBER = 6;
@@ -44760,21 +44760,21 @@ public boolean hasMistral() {
      * @return The mistral.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral() {
       if (kindCase_ == 6) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder() {
       if (kindCase_ == 6) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
     }
 
     public static final int OLLAMA_FIELD_NUMBER = 7;
@@ -44791,21 +44791,21 @@ public boolean hasOllama() {
      * @return The ollama.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama() {
       if (kindCase_ == 7) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder() {
       if (kindCase_ == 7) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
     }
 
     public static final int OPENAI_FIELD_NUMBER = 8;
@@ -44822,21 +44822,21 @@ public boolean hasOpenai() {
      * @return The openai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai() {
       if (kindCase_ == 8) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder() {
       if (kindCase_ == 8) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
     }
 
     public static final int GOOGLE_FIELD_NUMBER = 9;
@@ -44853,21 +44853,21 @@ public boolean hasGoogle() {
      * @return The google.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle() {
       if (kindCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeGoogleMetadata google = 9;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder() {
       if (kindCase_ == 9) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
     }
 
     public static final int DATABRICKS_FIELD_NUMBER = 10;
@@ -44884,21 +44884,21 @@ public boolean hasDatabricks() {
      * @return The databricks.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks() {
       if (kindCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder() {
       if (kindCase_ == 10) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
     }
 
     public static final int FRIENDLIAI_FIELD_NUMBER = 11;
@@ -44915,21 +44915,21 @@ public boolean hasFriendliai() {
      * @return The friendliai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai() {
       if (kindCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder() {
       if (kindCase_ == 11) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
     }
 
     public static final int NVIDIA_FIELD_NUMBER = 12;
@@ -44946,21 +44946,21 @@ public boolean hasNvidia() {
      * @return The nvidia.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia() {
       if (kindCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder() {
       if (kindCase_ == 12) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
     }
 
     public static final int XAI_FIELD_NUMBER = 13;
@@ -44977,21 +44977,21 @@ public boolean hasXai() {
      * @return The xai.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getXai() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getXai() {
       if (kindCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
     }
     /**
      * .weaviate.v1.GenerativeXAIMetadata xai = 13;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder() {
       if (kindCase_ == 13) {
-         return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
+         return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
       }
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
     }
 
     private byte memoizedIsInitialized = -1;
@@ -45009,43 +45009,43 @@ public final boolean isInitialized() {
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       if (kindCase_ == 1) {
-        output.writeMessage(1, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_);
+        output.writeMessage(1, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_);
       }
       if (kindCase_ == 2) {
-        output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_);
+        output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_);
       }
       if (kindCase_ == 3) {
-        output.writeMessage(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_);
+        output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_);
       }
       if (kindCase_ == 4) {
-        output.writeMessage(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_);
+        output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_);
       }
       if (kindCase_ == 5) {
-        output.writeMessage(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_);
+        output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_);
       }
       if (kindCase_ == 6) {
-        output.writeMessage(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_);
+        output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_);
       }
       if (kindCase_ == 7) {
-        output.writeMessage(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_);
+        output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_);
       }
       if (kindCase_ == 8) {
-        output.writeMessage(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_);
+        output.writeMessage(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_);
       }
       if (kindCase_ == 9) {
-        output.writeMessage(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_);
+        output.writeMessage(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_);
       }
       if (kindCase_ == 10) {
-        output.writeMessage(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_);
+        output.writeMessage(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_);
       }
       if (kindCase_ == 11) {
-        output.writeMessage(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_);
+        output.writeMessage(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_);
       }
       if (kindCase_ == 12) {
-        output.writeMessage(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_);
+        output.writeMessage(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_);
       }
       if (kindCase_ == 13) {
-        output.writeMessage(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_);
+        output.writeMessage(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_);
       }
       getUnknownFields().writeTo(output);
     }
@@ -45058,55 +45058,55 @@ public int getSerializedSize() {
       size = 0;
       if (kindCase_ == 1) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_);
+          .computeMessageSize(1, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_);
       }
       if (kindCase_ == 2) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_);
+          .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_);
       }
       if (kindCase_ == 3) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_);
+          .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_);
       }
       if (kindCase_ == 4) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_);
+          .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_);
       }
       if (kindCase_ == 5) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(5, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_);
+          .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_);
       }
       if (kindCase_ == 6) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(6, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_);
+          .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_);
       }
       if (kindCase_ == 7) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_);
+          .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_);
       }
       if (kindCase_ == 8) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(8, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_);
+          .computeMessageSize(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_);
       }
       if (kindCase_ == 9) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(9, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_);
+          .computeMessageSize(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_);
       }
       if (kindCase_ == 10) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(10, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_);
+          .computeMessageSize(10, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_);
       }
       if (kindCase_ == 11) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(11, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_);
+          .computeMessageSize(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_);
       }
       if (kindCase_ == 12) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(12, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_);
+          .computeMessageSize(12, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_);
       }
       if (kindCase_ == 13) {
         size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(13, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_);
+          .computeMessageSize(13, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSize = size;
@@ -45118,10 +45118,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata) obj;
 
       if (!getKindCase().equals(other.getKindCase())) return false;
       switch (kindCase_) {
@@ -45252,44 +45252,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -45297,26 +45297,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -45329,7 +45329,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -45350,21 +45350,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeMetadata)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.newBuilder()
       private Builder() {
 
       }
@@ -45425,17 +45425,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeMetadata_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -45443,19 +45443,19 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMet
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         buildPartialOneofs(result);
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata result) {
         int from_bitField0_ = bitField0_;
       }
 
-      private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata result) {
+      private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata result) {
         result.kindCase_ = kindCase_;
         result.kind_ = this.kind_;
         if (kindCase_ == 1 &&
@@ -45546,16 +45546,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance()) return this;
         switch (other.getKindCase()) {
           case ANTHROPIC: {
             mergeAnthropic(other.getAnthropic());
@@ -45763,7 +45763,7 @@ public Builder clearKind() {
       private int bitField0_;
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder> anthropicBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder> anthropicBuilder_;
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        * @return Whether the anthropic field is set.
@@ -45777,23 +45777,23 @@ public boolean hasAnthropic() {
        * @return The anthropic.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata getAnthropic() {
         if (anthropicBuilder_ == null) {
           if (kindCase_ == 1) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 1) {
             return anthropicBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
-      public Builder setAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata value) {
+      public Builder setAnthropic(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata value) {
         if (anthropicBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -45810,7 +45810,7 @@ public Builder setAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGen
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
       public Builder setAnthropic(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder builderForValue) {
         if (anthropicBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -45823,11 +45823,11 @@ public Builder setAnthropic(
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
-      public Builder mergeAnthropic(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata value) {
+      public Builder mergeAnthropic(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata value) {
         if (anthropicBuilder_ == null) {
           if (kindCase_ == 1 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -45865,36 +45865,36 @@ public Builder clearAnthropic() {
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder getAnthropicBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder getAnthropicBuilder() {
         return getAnthropicFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder getAnthropicOrBuilder() {
         if ((kindCase_ == 1) && (anthropicBuilder_ != null)) {
           return anthropicBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 1) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnthropicMetadata anthropic = 1;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder> 
           getAnthropicFieldBuilder() {
         if (anthropicBuilder_ == null) {
           if (!(kindCase_ == 1)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.getDefaultInstance();
           }
           anthropicBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnthropicMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -45905,7 +45905,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnt
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder> anyscaleBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder> anyscaleBuilder_;
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        * @return Whether the anyscale field is set.
@@ -45919,23 +45919,23 @@ public boolean hasAnyscale() {
        * @return The anyscale.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata getAnyscale() {
         if (anyscaleBuilder_ == null) {
           if (kindCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 2) {
             return anyscaleBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
-      public Builder setAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata value) {
+      public Builder setAnyscale(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata value) {
         if (anyscaleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -45952,7 +45952,7 @@ public Builder setAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGene
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
       public Builder setAnyscale(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder builderForValue) {
         if (anyscaleBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -45965,11 +45965,11 @@ public Builder setAnyscale(
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
-      public Builder mergeAnyscale(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata value) {
+      public Builder mergeAnyscale(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata value) {
         if (anyscaleBuilder_ == null) {
           if (kindCase_ == 2 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46007,36 +46007,36 @@ public Builder clearAnyscale() {
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder getAnyscaleBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder getAnyscaleBuilder() {
         return getAnyscaleFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder getAnyscaleOrBuilder() {
         if ((kindCase_ == 2) && (anyscaleBuilder_ != null)) {
           return anyscaleBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 2) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAnyscaleMetadata anyscale = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder> 
           getAnyscaleFieldBuilder() {
         if (anyscaleBuilder_ == null) {
           if (!(kindCase_ == 2)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.getDefaultInstance();
           }
           anyscaleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAnyscaleMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46047,7 +46047,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAny
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder> awsBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder> awsBuilder_;
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        * @return Whether the aws field is set.
@@ -46061,23 +46061,23 @@ public boolean hasAws() {
        * @return The aws.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata getAws() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata getAws() {
         if (awsBuilder_ == null) {
           if (kindCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 3) {
             return awsBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
-      public Builder setAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata value) {
+      public Builder setAws(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata value) {
         if (awsBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46094,7 +46094,7 @@ public Builder setAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerativ
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
       public Builder setAws(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder builderForValue) {
         if (awsBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46107,11 +46107,11 @@ public Builder setAws(
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
-      public Builder mergeAws(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata value) {
+      public Builder mergeAws(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata value) {
         if (awsBuilder_ == null) {
           if (kindCase_ == 3 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46149,36 +46149,36 @@ public Builder clearAws() {
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder getAwsBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder getAwsBuilder() {
         return getAwsFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder getAwsOrBuilder() {
         if ((kindCase_ == 3) && (awsBuilder_ != null)) {
           return awsBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 3) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeAWSMetadata aws = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder> 
           getAwsFieldBuilder() {
         if (awsBuilder_ == null) {
           if (!(kindCase_ == 3)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.getDefaultInstance();
           }
           awsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeAWSMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46189,7 +46189,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeAWS
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder> cohereBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder> cohereBuilder_;
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        * @return Whether the cohere field is set.
@@ -46203,23 +46203,23 @@ public boolean hasCohere() {
        * @return The cohere.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata getCohere() {
         if (cohereBuilder_ == null) {
           if (kindCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 4) {
             return cohereBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
-      public Builder setCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata value) {
+      public Builder setCohere(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata value) {
         if (cohereBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46236,7 +46236,7 @@ public Builder setCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
       public Builder setCohere(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder builderForValue) {
         if (cohereBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46249,11 +46249,11 @@ public Builder setCohere(
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
-      public Builder mergeCohere(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata value) {
+      public Builder mergeCohere(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata value) {
         if (cohereBuilder_ == null) {
           if (kindCase_ == 4 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46291,36 +46291,36 @@ public Builder clearCohere() {
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder getCohereBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder getCohereBuilder() {
         return getCohereFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder getCohereOrBuilder() {
         if ((kindCase_ == 4) && (cohereBuilder_ != null)) {
           return cohereBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 4) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeCohereMetadata cohere = 4;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder> 
           getCohereFieldBuilder() {
         if (cohereBuilder_ == null) {
           if (!(kindCase_ == 4)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.getDefaultInstance();
           }
           cohereBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeCohereMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46331,7 +46331,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeCoh
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder> dummyBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder> dummyBuilder_;
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        * @return Whether the dummy field is set.
@@ -46345,23 +46345,23 @@ public boolean hasDummy() {
        * @return The dummy.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata getDummy() {
         if (dummyBuilder_ == null) {
           if (kindCase_ == 5) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 5) {
             return dummyBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
-      public Builder setDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata value) {
+      public Builder setDummy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata value) {
         if (dummyBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46378,7 +46378,7 @@ public Builder setDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
       public Builder setDummy(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder builderForValue) {
         if (dummyBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46391,11 +46391,11 @@ public Builder setDummy(
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
-      public Builder mergeDummy(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata value) {
+      public Builder mergeDummy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata value) {
         if (dummyBuilder_ == null) {
           if (kindCase_ == 5 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46433,36 +46433,36 @@ public Builder clearDummy() {
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder getDummyBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder getDummyBuilder() {
         return getDummyFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder getDummyOrBuilder() {
         if ((kindCase_ == 5) && (dummyBuilder_ != null)) {
           return dummyBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 5) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDummyMetadata dummy = 5;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder> 
           getDummyFieldBuilder() {
         if (dummyBuilder_ == null) {
           if (!(kindCase_ == 5)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.getDefaultInstance();
           }
           dummyBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDummyMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46473,7 +46473,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDum
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder> mistralBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder> mistralBuilder_;
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        * @return Whether the mistral field is set.
@@ -46487,23 +46487,23 @@ public boolean hasMistral() {
        * @return The mistral.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata getMistral() {
         if (mistralBuilder_ == null) {
           if (kindCase_ == 6) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 6) {
             return mistralBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
-      public Builder setMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata value) {
+      public Builder setMistral(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata value) {
         if (mistralBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46520,7 +46520,7 @@ public Builder setMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGener
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
       public Builder setMistral(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder builderForValue) {
         if (mistralBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46533,11 +46533,11 @@ public Builder setMistral(
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
-      public Builder mergeMistral(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata value) {
+      public Builder mergeMistral(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata value) {
         if (mistralBuilder_ == null) {
           if (kindCase_ == 6 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46575,36 +46575,36 @@ public Builder clearMistral() {
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder getMistralBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder getMistralBuilder() {
         return getMistralFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder getMistralOrBuilder() {
         if ((kindCase_ == 6) && (mistralBuilder_ != null)) {
           return mistralBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 6) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeMistralMetadata mistral = 6;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder> 
           getMistralFieldBuilder() {
         if (mistralBuilder_ == null) {
           if (!(kindCase_ == 6)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.getDefaultInstance();
           }
           mistralBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMistralMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46615,7 +46615,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMis
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder> ollamaBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder> ollamaBuilder_;
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        * @return Whether the ollama field is set.
@@ -46629,23 +46629,23 @@ public boolean hasOllama() {
        * @return The ollama.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata getOllama() {
         if (ollamaBuilder_ == null) {
           if (kindCase_ == 7) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 7) {
             return ollamaBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
-      public Builder setOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata value) {
+      public Builder setOllama(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata value) {
         if (ollamaBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46662,7 +46662,7 @@ public Builder setOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
       public Builder setOllama(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder builderForValue) {
         if (ollamaBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46675,11 +46675,11 @@ public Builder setOllama(
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
-      public Builder mergeOllama(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata value) {
+      public Builder mergeOllama(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata value) {
         if (ollamaBuilder_ == null) {
           if (kindCase_ == 7 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46717,36 +46717,36 @@ public Builder clearOllama() {
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder getOllamaBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder getOllamaBuilder() {
         return getOllamaFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder getOllamaOrBuilder() {
         if ((kindCase_ == 7) && (ollamaBuilder_ != null)) {
           return ollamaBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 7) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOllamaMetadata ollama = 7;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder> 
           getOllamaFieldBuilder() {
         if (ollamaBuilder_ == null) {
           if (!(kindCase_ == 7)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.getDefaultInstance();
           }
           ollamaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOllamaMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46757,7 +46757,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOll
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder> openaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder> openaiBuilder_;
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        * @return Whether the openai field is set.
@@ -46771,23 +46771,23 @@ public boolean hasOpenai() {
        * @return The openai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata getOpenai() {
         if (openaiBuilder_ == null) {
           if (kindCase_ == 8) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 8) {
             return openaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
-      public Builder setOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata value) {
+      public Builder setOpenai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata value) {
         if (openaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46804,7 +46804,7 @@ public Builder setOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
       public Builder setOpenai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder builderForValue) {
         if (openaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46817,11 +46817,11 @@ public Builder setOpenai(
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
-      public Builder mergeOpenai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata value) {
+      public Builder mergeOpenai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata value) {
         if (openaiBuilder_ == null) {
           if (kindCase_ == 8 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -46859,36 +46859,36 @@ public Builder clearOpenai() {
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder getOpenaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder getOpenaiBuilder() {
         return getOpenaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder getOpenaiOrBuilder() {
         if ((kindCase_ == 8) && (openaiBuilder_ != null)) {
           return openaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 8) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeOpenAIMetadata openai = 8;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder> 
           getOpenaiFieldBuilder() {
         if (openaiBuilder_ == null) {
           if (!(kindCase_ == 8)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.getDefaultInstance();
           }
           openaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeOpenAIMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -46899,7 +46899,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeOpe
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder> googleBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder> googleBuilder_;
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        * @return Whether the google field is set.
@@ -46913,23 +46913,23 @@ public boolean hasGoogle() {
        * @return The google.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata getGoogle() {
         if (googleBuilder_ == null) {
           if (kindCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 9) {
             return googleBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
-      public Builder setGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata value) {
+      public Builder setGoogle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata value) {
         if (googleBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -46946,7 +46946,7 @@ public Builder setGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
       public Builder setGoogle(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder builderForValue) {
         if (googleBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -46959,11 +46959,11 @@ public Builder setGoogle(
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
-      public Builder mergeGoogle(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata value) {
+      public Builder mergeGoogle(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata value) {
         if (googleBuilder_ == null) {
           if (kindCase_ == 9 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -47001,36 +47001,36 @@ public Builder clearGoogle() {
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder getGoogleBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder getGoogleBuilder() {
         return getGoogleFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder getGoogleOrBuilder() {
         if ((kindCase_ == 9) && (googleBuilder_ != null)) {
           return googleBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 9) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeGoogleMetadata google = 9;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder> 
           getGoogleFieldBuilder() {
         if (googleBuilder_ == null) {
           if (!(kindCase_ == 9)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.getDefaultInstance();
           }
           googleBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeGoogleMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -47041,7 +47041,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeGoo
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder> databricksBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder> databricksBuilder_;
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        * @return Whether the databricks field is set.
@@ -47055,23 +47055,23 @@ public boolean hasDatabricks() {
        * @return The databricks.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata getDatabricks() {
         if (databricksBuilder_ == null) {
           if (kindCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 10) {
             return databricksBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
-      public Builder setDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata value) {
+      public Builder setDatabricks(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata value) {
         if (databricksBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -47088,7 +47088,7 @@ public Builder setDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGe
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
       public Builder setDatabricks(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder builderForValue) {
         if (databricksBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -47101,11 +47101,11 @@ public Builder setDatabricks(
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
-      public Builder mergeDatabricks(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata value) {
+      public Builder mergeDatabricks(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata value) {
         if (databricksBuilder_ == null) {
           if (kindCase_ == 10 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -47143,36 +47143,36 @@ public Builder clearDatabricks() {
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder getDatabricksBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder getDatabricksBuilder() {
         return getDatabricksFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder getDatabricksOrBuilder() {
         if ((kindCase_ == 10) && (databricksBuilder_ != null)) {
           return databricksBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 10) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeDatabricksMetadata databricks = 10;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder> 
           getDatabricksFieldBuilder() {
         if (databricksBuilder_ == null) {
           if (!(kindCase_ == 10)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.getDefaultInstance();
           }
           databricksBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDatabricksMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -47183,7 +47183,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDat
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder> friendliaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder> friendliaiBuilder_;
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        * @return Whether the friendliai field is set.
@@ -47197,23 +47197,23 @@ public boolean hasFriendliai() {
        * @return The friendliai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata getFriendliai() {
         if (friendliaiBuilder_ == null) {
           if (kindCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 11) {
             return friendliaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
-      public Builder setFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata value) {
+      public Builder setFriendliai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata value) {
         if (friendliaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -47230,7 +47230,7 @@ public Builder setFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGe
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
       public Builder setFriendliai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder builderForValue) {
         if (friendliaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -47243,11 +47243,11 @@ public Builder setFriendliai(
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
-      public Builder mergeFriendliai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata value) {
+      public Builder mergeFriendliai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata value) {
         if (friendliaiBuilder_ == null) {
           if (kindCase_ == 11 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -47285,36 +47285,36 @@ public Builder clearFriendliai() {
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder getFriendliaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder getFriendliaiBuilder() {
         return getFriendliaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder getFriendliaiOrBuilder() {
         if ((kindCase_ == 11) && (friendliaiBuilder_ != null)) {
           return friendliaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 11) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeFriendliAIMetadata friendliai = 11;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder> 
           getFriendliaiFieldBuilder() {
         if (friendliaiBuilder_ == null) {
           if (!(kindCase_ == 11)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.getDefaultInstance();
           }
           friendliaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeFriendliAIMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -47325,7 +47325,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeFri
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder> nvidiaBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder> nvidiaBuilder_;
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        * @return Whether the nvidia field is set.
@@ -47339,23 +47339,23 @@ public boolean hasNvidia() {
        * @return The nvidia.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata getNvidia() {
         if (nvidiaBuilder_ == null) {
           if (kindCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 12) {
             return nvidiaBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
-      public Builder setNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata value) {
+      public Builder setNvidia(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata value) {
         if (nvidiaBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -47372,7 +47372,7 @@ public Builder setNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
       public Builder setNvidia(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder builderForValue) {
         if (nvidiaBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -47385,11 +47385,11 @@ public Builder setNvidia(
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
-      public Builder mergeNvidia(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata value) {
+      public Builder mergeNvidia(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata value) {
         if (nvidiaBuilder_ == null) {
           if (kindCase_ == 12 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -47427,36 +47427,36 @@ public Builder clearNvidia() {
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder getNvidiaBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder getNvidiaBuilder() {
         return getNvidiaFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder getNvidiaOrBuilder() {
         if ((kindCase_ == 12) && (nvidiaBuilder_ != null)) {
           return nvidiaBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 12) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeNvidiaMetadata nvidia = 12;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder> 
           getNvidiaFieldBuilder() {
         if (nvidiaBuilder_ == null) {
           if (!(kindCase_ == 12)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.getDefaultInstance();
           }
           nvidiaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeNvidiaMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -47467,7 +47467,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeNvi
       }
 
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder> xaiBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder> xaiBuilder_;
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        * @return Whether the xai field is set.
@@ -47481,23 +47481,23 @@ public boolean hasXai() {
        * @return The xai.
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata getXai() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata getXai() {
         if (xaiBuilder_ == null) {
           if (kindCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
         } else {
           if (kindCase_ == 13) {
             return xaiBuilder_.getMessage();
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
-      public Builder setXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata value) {
+      public Builder setXai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata value) {
         if (xaiBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -47514,7 +47514,7 @@ public Builder setXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerativ
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
       public Builder setXai(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder builderForValue) {
         if (xaiBuilder_ == null) {
           kind_ = builderForValue.build();
           onChanged();
@@ -47527,11 +47527,11 @@ public Builder setXai(
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
-      public Builder mergeXai(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata value) {
+      public Builder mergeXai(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata value) {
         if (xaiBuilder_ == null) {
           if (kindCase_ == 13 &&
-              kind_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance()) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_)
+              kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance()) {
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_)
                 .mergeFrom(value).buildPartial();
           } else {
             kind_ = value;
@@ -47569,36 +47569,36 @@ public Builder clearXai() {
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder getXaiBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder getXaiBuilder() {
         return getXaiFieldBuilder().getBuilder();
       }
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder getXaiOrBuilder() {
         if ((kindCase_ == 13) && (xaiBuilder_ != null)) {
           return xaiBuilder_.getMessageOrBuilder();
         } else {
           if (kindCase_ == 13) {
-            return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
+            return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_;
           }
-          return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+          return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
         }
       }
       /**
        * .weaviate.v1.GenerativeXAIMetadata xai = 13;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder> 
           getXaiFieldBuilder() {
         if (xaiBuilder_ == null) {
           if (!(kindCase_ == 13)) {
-            kind_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
+            kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.getDefaultInstance();
           }
           xaiBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder>(
-                  (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_,
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadataOrBuilder>(
+                  (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeXAIMetadata) kind_,
                   getParentForChildren(),
                   isClean());
           kind_ = null;
@@ -47624,12 +47624,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeMetadata)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -47665,7 +47665,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -47696,11 +47696,11 @@ public interface GenerativeReplyOrBuilder extends
      * optional .weaviate.v1.GenerativeDebug debug = 2;
      * @return The debug.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDebug();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDebug();
     /**
      * optional .weaviate.v1.GenerativeDebug debug = 2;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder();
 
     /**
      * optional .weaviate.v1.GenerativeMetadata metadata = 3;
@@ -47711,11 +47711,11 @@ public interface GenerativeReplyOrBuilder extends
      * optional .weaviate.v1.GenerativeMetadata metadata = 3;
      * @return The metadata.
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getMetadata();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getMetadata();
     /**
      * optional .weaviate.v1.GenerativeMetadata metadata = 3;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder();
   }
   /**
    * Protobuf type {@code weaviate.v1.GenerativeReply}
@@ -47742,15 +47742,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder.class);
     }
 
     private int bitField0_;
@@ -47794,7 +47794,7 @@ public java.lang.String getResult() {
     }
 
     public static final int DEBUG_FIELD_NUMBER = 2;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug debug_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug debug_;
     /**
      * optional .weaviate.v1.GenerativeDebug debug = 2;
      * @return Whether the debug field is set.
@@ -47808,19 +47808,19 @@ public boolean hasDebug() {
      * @return The debug.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDebug() {
-      return debug_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDebug() {
+      return debug_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
     }
     /**
      * optional .weaviate.v1.GenerativeDebug debug = 2;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder() {
-      return debug_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder() {
+      return debug_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
     }
 
     public static final int METADATA_FIELD_NUMBER = 3;
-    private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata metadata_;
+    private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata metadata_;
     /**
      * optional .weaviate.v1.GenerativeMetadata metadata = 3;
      * @return Whether the metadata field is set.
@@ -47834,15 +47834,15 @@ public boolean hasMetadata() {
      * @return The metadata.
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getMetadata() {
-      return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getMetadata() {
+      return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
     }
     /**
      * optional .weaviate.v1.GenerativeMetadata metadata = 3;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder() {
-      return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder() {
+      return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
     }
 
     private byte memoizedIsInitialized = -1;
@@ -47898,10 +47898,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply) obj;
 
       if (!getResult()
           .equals(other.getResult())) return false;
@@ -47941,44 +47941,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -47986,26 +47986,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -48018,7 +48018,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -48039,21 +48039,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeReply)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
@@ -48091,17 +48091,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeReply_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -48109,14 +48109,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeRep
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply result) {
         int from_bitField0_ = bitField0_;
         if (((from_bitField0_ & 0x00000001) != 0)) {
           result.result_ = result_;
@@ -48171,16 +48171,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance()) return this;
         if (!other.getResult().isEmpty()) {
           result_ = other.result_;
           bitField0_ |= 0x00000001;
@@ -48326,9 +48326,9 @@ public Builder setResultBytes(
         return this;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug debug_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug debug_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder> debugBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder> debugBuilder_;
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        * @return Whether the debug field is set.
@@ -48340,9 +48340,9 @@ public boolean hasDebug() {
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        * @return The debug.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDebug() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDebug() {
         if (debugBuilder_ == null) {
-          return debug_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
+          return debug_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
         } else {
           return debugBuilder_.getMessage();
         }
@@ -48350,7 +48350,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
-      public Builder setDebug(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug value) {
+      public Builder setDebug(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug value) {
         if (debugBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -48367,7 +48367,7 @@ public Builder setDebug(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerat
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
       public Builder setDebug(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder builderForValue) {
         if (debugBuilder_ == null) {
           debug_ = builderForValue.build();
         } else {
@@ -48380,11 +48380,11 @@ public Builder setDebug(
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
-      public Builder mergeDebug(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug value) {
+      public Builder mergeDebug(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug value) {
         if (debugBuilder_ == null) {
           if (((bitField0_ & 0x00000002) != 0) &&
             debug_ != null &&
-            debug_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance()) {
+            debug_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance()) {
             getDebugBuilder().mergeFrom(value);
           } else {
             debug_ = value;
@@ -48414,7 +48414,7 @@ public Builder clearDebug() {
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder getDebugBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder getDebugBuilder() {
         bitField0_ |= 0x00000002;
         onChanged();
         return getDebugFieldBuilder().getBuilder();
@@ -48422,23 +48422,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder getDebugOrBuilder() {
         if (debugBuilder_ != null) {
           return debugBuilder_.getMessageOrBuilder();
         } else {
           return debug_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance() : debug_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeDebug debug = 2;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder> 
           getDebugFieldBuilder() {
         if (debugBuilder_ == null) {
           debugBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder>(
                   getDebug(),
                   getParentForChildren(),
                   isClean());
@@ -48447,9 +48447,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
         return debugBuilder_;
       }
 
-      private io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata metadata_;
+      private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata metadata_;
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder> metadataBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder> metadataBuilder_;
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        * @return Whether the metadata field is set.
@@ -48461,9 +48461,9 @@ public boolean hasMetadata() {
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        * @return The metadata.
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata getMetadata() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata getMetadata() {
         if (metadataBuilder_ == null) {
-          return metadata_ == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
+          return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
         } else {
           return metadataBuilder_.getMessage();
         }
@@ -48471,7 +48471,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMet
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
-      public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata value) {
+      public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata value) {
         if (metadataBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -48488,7 +48488,7 @@ public Builder setMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGene
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
       public Builder setMetadata(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder builderForValue) {
         if (metadataBuilder_ == null) {
           metadata_ = builderForValue.build();
         } else {
@@ -48501,11 +48501,11 @@ public Builder setMetadata(
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
-      public Builder mergeMetadata(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata value) {
+      public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata value) {
         if (metadataBuilder_ == null) {
           if (((bitField0_ & 0x00000004) != 0) &&
             metadata_ != null &&
-            metadata_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance()) {
+            metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance()) {
             getMetadataBuilder().mergeFrom(value);
           } else {
             metadata_ = value;
@@ -48535,7 +48535,7 @@ public Builder clearMetadata() {
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder getMetadataBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder getMetadataBuilder() {
         bitField0_ |= 0x00000004;
         onChanged();
         return getMetadataFieldBuilder().getBuilder();
@@ -48543,23 +48543,23 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMet
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder getMetadataOrBuilder() {
         if (metadataBuilder_ != null) {
           return metadataBuilder_.getMessageOrBuilder();
         } else {
           return metadata_ == null ?
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.getDefaultInstance() : metadata_;
         }
       }
       /**
        * optional .weaviate.v1.GenerativeMetadata metadata = 3;
        */
       private com.google.protobuf.SingleFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder> 
           getMetadataFieldBuilder() {
         if (metadataBuilder_ == null) {
           metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeMetadataOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadata.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeMetadataOrBuilder>(
                   getMetadata(),
                   getParentForChildren(),
                   isClean());
@@ -48584,12 +48584,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeReply)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -48625,7 +48625,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -48638,12 +48638,12 @@ public interface GenerativeResultOrBuilder extends
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
-    java.util.List 
+    java.util.List 
         getValuesList();
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getValues(int index);
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getValues(int index);
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
@@ -48651,12 +48651,12 @@ public interface GenerativeResultOrBuilder extends
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
-    java.util.List 
+    java.util.List 
         getValuesOrBuilderList();
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
         int index);
   }
   /**
@@ -48684,32 +48684,32 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder.class);
     }
 
     public static final int VALUES_FIELD_NUMBER = 1;
     @SuppressWarnings("serial")
-    private java.util.List values_;
+    private java.util.List values_;
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
     @java.lang.Override
-    public java.util.List getValuesList() {
+    public java.util.List getValuesList() {
       return values_;
     }
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
     @java.lang.Override
-    public java.util.List 
+    public java.util.List 
         getValuesOrBuilderList() {
       return values_;
     }
@@ -48724,14 +48724,14 @@ public int getValuesCount() {
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getValues(int index) {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getValues(int index) {
       return values_.get(index);
     }
     /**
      * repeated .weaviate.v1.GenerativeReply values = 1;
      */
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
         int index) {
       return values_.get(index);
     }
@@ -48776,10 +48776,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult) obj;
 
       if (!getValuesList()
           .equals(other.getValuesList())) return false;
@@ -48803,44 +48803,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -48848,26 +48848,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -48880,7 +48880,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -48901,21 +48901,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeResult)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResultOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.newBuilder()
       private Builder() {
 
       }
@@ -48942,17 +48942,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeResult_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -48960,15 +48960,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeRes
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult(this);
         buildPartialRepeatedFields(result);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult result) {
+      private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult result) {
         if (valuesBuilder_ == null) {
           if (((bitField0_ & 0x00000001) != 0)) {
             values_ = java.util.Collections.unmodifiableList(values_);
@@ -48980,7 +48980,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav
         }
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult result) {
         int from_bitField0_ = bitField0_;
       }
 
@@ -49018,16 +49018,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) return this;
         if (valuesBuilder_ == null) {
           if (!other.values_.isEmpty()) {
             if (values_.isEmpty()) {
@@ -49081,9 +49081,9 @@ public Builder mergeFrom(
                 done = true;
                 break;
               case 10: {
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply m =
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply m =
                     input.readMessage(
-                        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.parser(),
+                        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.parser(),
                         extensionRegistry);
                 if (valuesBuilder_ == null) {
                   ensureValuesIsMutable();
@@ -49110,22 +49110,22 @@ public Builder mergeFrom(
       }
       private int bitField0_;
 
-      private java.util.List values_ =
+      private java.util.List values_ =
         java.util.Collections.emptyList();
       private void ensureValuesIsMutable() {
         if (!((bitField0_ & 0x00000001) != 0)) {
-          values_ = new java.util.ArrayList(values_);
+          values_ = new java.util.ArrayList(values_);
           bitField0_ |= 0x00000001;
          }
       }
 
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder> valuesBuilder_;
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder> valuesBuilder_;
 
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public java.util.List getValuesList() {
+      public java.util.List getValuesList() {
         if (valuesBuilder_ == null) {
           return java.util.Collections.unmodifiableList(values_);
         } else {
@@ -49145,7 +49145,7 @@ public int getValuesCount() {
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply getValues(int index) {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getValues(int index) {
         if (valuesBuilder_ == null) {
           return values_.get(index);
         } else {
@@ -49156,7 +49156,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeRep
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder setValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -49173,7 +49173,7 @@ public Builder setValues(
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder setValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.set(index, builderForValue.build());
@@ -49186,7 +49186,7 @@ public Builder setValues(
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply value) {
+      public Builder addValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -49203,7 +49203,7 @@ public Builder addValues(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenera
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder addValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply value) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply value) {
         if (valuesBuilder_ == null) {
           if (value == null) {
             throw new NullPointerException();
@@ -49220,7 +49220,7 @@ public Builder addValues(
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder addValues(
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.add(builderForValue.build());
@@ -49234,7 +49234,7 @@ public Builder addValues(
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder addValues(
-          int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
+          int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           values_.add(index, builderForValue.build());
@@ -49248,7 +49248,7 @@ public Builder addValues(
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
       public Builder addAllValues(
-          java.lang.Iterable values) {
+          java.lang.Iterable values) {
         if (valuesBuilder_ == null) {
           ensureValuesIsMutable();
           com.google.protobuf.AbstractMessageLite.Builder.addAll(
@@ -49288,14 +49288,14 @@ public Builder removeValues(int index) {
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder getValuesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder getValuesBuilder(
           int index) {
         return getValuesFieldBuilder().getBuilder(index);
       }
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getValuesOrBuilder(
           int index) {
         if (valuesBuilder_ == null) {
           return values_.get(index);  } else {
@@ -49305,7 +49305,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeRep
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public java.util.List 
+      public java.util.List 
            getValuesOrBuilderList() {
         if (valuesBuilder_ != null) {
           return valuesBuilder_.getMessageOrBuilderList();
@@ -49316,31 +49316,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeRep
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder addValuesBuilder() {
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder addValuesBuilder() {
         return getValuesFieldBuilder().addBuilder(
-            io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance());
+            io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder addValuesBuilder(
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder addValuesBuilder(
           int index) {
         return getValuesFieldBuilder().addBuilder(
-            index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance());
+            index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance());
       }
       /**
        * repeated .weaviate.v1.GenerativeReply values = 1;
        */
-      public java.util.List 
+      public java.util.List 
            getValuesBuilderList() {
         return getValuesFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder> 
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder> 
           getValuesFieldBuilder() {
         if (valuesBuilder_ == null) {
           valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeReplyOrBuilder>(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder>(
                   values_,
                   ((bitField0_ & 0x00000001) != 0),
                   getParentForChildren(),
@@ -49366,12 +49366,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeResult)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -49407,7 +49407,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeResult getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -49459,15 +49459,15 @@ protected java.lang.Object newInstance(
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
     }
 
     @java.lang.Override
     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_fieldAccessorTable
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_fieldAccessorTable
           .ensureFieldAccessorsInitialized(
-              io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder.class);
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder.class);
     }
 
     private int bitField0_;
@@ -49557,10 +49557,10 @@ public boolean equals(final java.lang.Object obj) {
       if (obj == this) {
        return true;
       }
-      if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug)) {
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug)) {
         return super.equals(obj);
       }
-      io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug) obj;
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug) obj;
 
       if (hasFullPrompt() != other.hasFullPrompt()) return false;
       if (hasFullPrompt()) {
@@ -49587,44 +49587,44 @@ public int hashCode() {
       return hash;
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         java.nio.ByteBuffer data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         java.nio.ByteBuffer data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(byte[] data)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return PARSER.parseFrom(data, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -49632,26 +49632,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
           .parseWithIOException(PARSER, input, extensionRegistry);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseDelimitedFrom(java.io.InputStream input)
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input);
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseDelimitedFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return com.google.protobuf.GeneratedMessageV3
           .parseWithIOException(PARSER, input);
     }
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug parseFrom(
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -49664,7 +49664,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.Genera
     public static Builder newBuilder() {
       return DEFAULT_INSTANCE.toBuilder();
     }
-    public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug prototype) {
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug prototype) {
       return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
     }
     @java.lang.Override
@@ -49685,21 +49685,21 @@ protected Builder newBuilderForType(
     public static final class Builder extends
         com.google.protobuf.GeneratedMessageV3.Builder implements
         // @@protoc_insertion_point(builder_implements:weaviate.v1.GenerativeDebug)
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebugOrBuilder {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebugOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
       }
 
       @java.lang.Override
       protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_fieldAccessorTable
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_fieldAccessorTable
             .ensureFieldAccessorsInitialized(
-                io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.Builder.class);
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.Builder.class);
       }
 
-      // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.newBuilder()
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.newBuilder()
       private Builder() {
 
       }
@@ -49720,17 +49720,17 @@ public Builder clear() {
       @java.lang.Override
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.internal_static_weaviate_v1_GenerativeDebug_descriptor;
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDefaultInstanceForType() {
-        return io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance();
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug build() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug result = buildPartial();
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug result = buildPartial();
         if (!result.isInitialized()) {
           throw newUninitializedMessageException(result);
         }
@@ -49738,14 +49738,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
       }
 
       @java.lang.Override
-      public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug buildPartial() {
-        io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug(this);
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug(this);
         if (bitField0_ != 0) { buildPartial0(result); }
         onBuilt();
         return result;
       }
 
-      private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug result) {
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug result) {
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) != 0)) {
@@ -49789,16 +49789,16 @@ public Builder addRepeatedField(
       }
       @java.lang.Override
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug) {
-          return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug)other);
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug other) {
-        if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance()) return this;
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug.getDefaultInstance()) return this;
         if (other.hasFullPrompt()) {
           fullPrompt_ = other.fullPrompt_;
           bitField0_ |= 0x00000001;
@@ -49947,12 +49947,12 @@ public final Builder mergeUnknownFields(
     }
 
     // @@protoc_insertion_point(class_scope:weaviate.v1.GenerativeDebug)
-    private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug DEFAULT_INSTANCE;
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug DEFAULT_INSTANCE;
     static {
-      DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug();
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug();
     }
 
-    public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDefaultInstance() {
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDefaultInstance() {
       return DEFAULT_INSTANCE;
     }
 
@@ -49988,7 +49988,7 @@ public com.google.protobuf.Parser getParserForType() {
     }
 
     @java.lang.Override
-    public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDebug getDefaultInstanceForType() {
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeDebug getDefaultInstanceForType() {
       return DEFAULT_INSTANCE;
     }
 
@@ -50498,15 +50498,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
       "B\010\n\006_debugB\013\n\t_metadata\"@\n\020GenerativeRes" +
       "ult\022,\n\006values\030\001 \003(\0132\034.weaviate.v1.Genera" +
       "tiveReply\";\n\017GenerativeDebug\022\030\n\013full_pro" +
-      "mpt\030\001 \001(\tH\000\210\001\001B\016\n\014_full_promptBt\n#io.wea" +
-      "viate.client.grpc.protocol.v1B\027WeaviateP" +
-      "rotoGenerativeZ4github.com/weaviate/weav" +
-      "iate/grpc/generated;protocolb\006proto3"
+      "mpt\030\001 \001(\tH\000\210\001\001B\016\n\014_full_promptBH\n-io.wea" +
+      "viate.client6.v1.internal.grpc.protocolB" +
+      "\027WeaviateProtoGenerativeb\006proto3"
     };
     descriptor = com.google.protobuf.Descriptors.FileDescriptor
       .internalBuildGeneratedFileFrom(descriptorData,
         new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor(),
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(),
         });
     internal_static_weaviate_v1_GenerativeSearch_descriptor =
       getDescriptor().getMessageTypes().get(0);
@@ -50796,7 +50795,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoGenerative.GenerativeDeb
       com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
         internal_static_weaviate_v1_GenerativeDebug_descriptor,
         new java.lang.String[] { "FullPrompt", "FullPrompt", });
-    io.weaviate.client.grpc.protocol.v1.WeaviateProtoBase.getDescriptor();
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor();
   }
 
   // @@protoc_insertion_point(outer_class_scope)
diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoProperties.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoProperties.java
new file mode 100644
index 000000000..1b54c851a
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoProperties.java
@@ -0,0 +1,11613 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: v1/properties.proto
+
+package io.weaviate.client6.v1.internal.grpc.protocol;
+
+public final class WeaviateProtoProperties {
+  private WeaviateProtoProperties() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  public interface PropertiesOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.Properties)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    int getFieldsCount();
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    boolean containsFields(
+        java.lang.String key);
+    /**
+     * Use {@link #getFieldsMap()} instead.
+     */
+    @java.lang.Deprecated
+    java.util.Map
+    getFields();
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    java.util.Map
+    getFieldsMap();
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrDefault(
+        java.lang.String key,
+        /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value defaultValue);
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrThrow(
+        java.lang.String key);
+  }
+  /**
+   * Protobuf type {@code weaviate.v1.Properties}
+   */
+  public static final class Properties extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:weaviate.v1.Properties)
+      PropertiesOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use Properties.newBuilder() to construct.
+    private Properties(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+      super(builder);
+    }
+    private Properties() {
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new Properties();
+    }
+
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor;
+    }
+
+    @SuppressWarnings({"rawtypes"})
+    @java.lang.Override
+    protected com.google.protobuf.MapField internalGetMapField(
+        int number) {
+      switch (number) {
+        case 1:
+          return internalGetFields();
+        default:
+          throw new RuntimeException(
+              "Invalid map field number: " + number);
+      }
+    }
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder.class);
+    }
+
+    public static final int FIELDS_FIELD_NUMBER = 1;
+    private static final class FieldsDefaultEntryHolder {
+      static final com.google.protobuf.MapEntry<
+          java.lang.String, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value> defaultEntry =
+              com.google.protobuf.MapEntry
+              .newDefaultInstance(
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_FieldsEntry_descriptor, 
+                  com.google.protobuf.WireFormat.FieldType.STRING,
+                  "",
+                  com.google.protobuf.WireFormat.FieldType.MESSAGE,
+                  io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.getDefaultInstance());
+    }
+    @SuppressWarnings("serial")
+    private com.google.protobuf.MapField<
+        java.lang.String, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value> fields_;
+    private com.google.protobuf.MapField
+    internalGetFields() {
+      if (fields_ == null) {
+        return com.google.protobuf.MapField.emptyMapField(
+            FieldsDefaultEntryHolder.defaultEntry);
+      }
+      return fields_;
+    }
+    public int getFieldsCount() {
+      return internalGetFields().getMap().size();
+    }
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    @java.lang.Override
+    public boolean containsFields(
+        java.lang.String key) {
+      if (key == null) { throw new NullPointerException("map key"); }
+      return internalGetFields().getMap().containsKey(key);
+    }
+    /**
+     * Use {@link #getFieldsMap()} instead.
+     */
+    @java.lang.Override
+    @java.lang.Deprecated
+    public java.util.Map getFields() {
+      return getFieldsMap();
+    }
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    @java.lang.Override
+    public java.util.Map getFieldsMap() {
+      return internalGetFields().getMap();
+    }
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    @java.lang.Override
+    public /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrDefault(
+        java.lang.String key,
+        /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value defaultValue) {
+      if (key == null) { throw new NullPointerException("map key"); }
+      java.util.Map map =
+          internalGetFields().getMap();
+      return map.containsKey(key) ? map.get(key) : defaultValue;
+    }
+    /**
+     * map<string, .weaviate.v1.Value> fields = 1;
+     */
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrThrow(
+        java.lang.String key) {
+      if (key == null) { throw new NullPointerException("map key"); }
+      java.util.Map map =
+          internalGetFields().getMap();
+      if (!map.containsKey(key)) {
+        throw new java.lang.IllegalArgumentException();
+      }
+      return map.get(key);
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      com.google.protobuf.GeneratedMessageV3
+        .serializeStringMapTo(
+          output,
+          internalGetFields(),
+          FieldsDefaultEntryHolder.defaultEntry,
+          1);
+      getUnknownFields().writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      for (java.util.Map.Entry entry
+           : internalGetFields().getMap().entrySet()) {
+        com.google.protobuf.MapEntry
+        fields__ = FieldsDefaultEntryHolder.defaultEntry.newBuilderForType()
+            .setKey(entry.getKey())
+            .setValue(entry.getValue())
+            .build();
+        size += com.google.protobuf.CodedOutputStream
+            .computeMessageSize(1, fields__);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties)) {
+        return super.equals(obj);
+      }
+      io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) obj;
+
+      if (!internalGetFields().equals(
+          other.internalGetFields())) return false;
+      if (!getUnknownFields().equals(other.getUnknownFields())) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      if (!internalGetFields().getMap().isEmpty()) {
+        hash = (37 * hash) + FIELDS_FIELD_NUMBER;
+        hash = (53 * hash) + internalGetFields().hashCode();
+      }
+      hash = (29 * hash) + getUnknownFields().hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code weaviate.v1.Properties}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder implements
+        // @@protoc_insertion_point(builder_implements:weaviate.v1.Properties)
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor;
+      }
+
+      @SuppressWarnings({"rawtypes"})
+      protected com.google.protobuf.MapField internalGetMapField(
+          int number) {
+        switch (number) {
+          case 1:
+            return internalGetFields();
+          default:
+            throw new RuntimeException(
+                "Invalid map field number: " + number);
+        }
+      }
+      @SuppressWarnings({"rawtypes"})
+      protected com.google.protobuf.MapField internalGetMutableMapField(
+          int number) {
+        switch (number) {
+          case 1:
+            return internalGetMutableFields();
+          default:
+            throw new RuntimeException(
+                "Invalid map field number: " + number);
+        }
+      }
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder.class);
+      }
+
+      // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.newBuilder()
+      private Builder() {
+
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        bitField0_ = 0;
+        internalGetMutableFields().clear();
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Properties_descriptor;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getDefaultInstanceForType() {
+        return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties build() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties buildPartial() {
+        io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties(this);
+        if (bitField0_ != 0) { buildPartial0(result); }
+        onBuilt();
+        return result;
+      }
+
+      private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties result) {
+        int from_bitField0_ = bitField0_;
+        if (((from_bitField0_ & 0x00000001) != 0)) {
+          result.fields_ = internalGetFields();
+          result.fields_.makeImmutable();
+        }
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) {
+          return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties other) {
+        if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance()) return this;
+        internalGetMutableFields().mergeFrom(
+            other.internalGetFields());
+        bitField0_ |= 0x00000001;
+        this.mergeUnknownFields(other.getUnknownFields());
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 10: {
+                com.google.protobuf.MapEntry
+                fields__ = input.readMessage(
+                    FieldsDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry);
+                internalGetMutableFields().getMutableMap().put(
+                    fields__.getKey(), fields__.getValue());
+                bitField0_ |= 0x00000001;
+                break;
+              } // case 10
+              default: {
+                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                  done = true; // was an endgroup tag
+                }
+                break;
+              } // default:
+            } // switch (tag)
+          } // while (!done)
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.unwrapIOException();
+        } finally {
+          onChanged();
+        } // finally
+        return this;
+      }
+      private int bitField0_;
+
+      private com.google.protobuf.MapField<
+          java.lang.String, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value> fields_;
+      private com.google.protobuf.MapField
+          internalGetFields() {
+        if (fields_ == null) {
+          return com.google.protobuf.MapField.emptyMapField(
+              FieldsDefaultEntryHolder.defaultEntry);
+        }
+        return fields_;
+      }
+      private com.google.protobuf.MapField
+          internalGetMutableFields() {
+        if (fields_ == null) {
+          fields_ = com.google.protobuf.MapField.newMapField(
+              FieldsDefaultEntryHolder.defaultEntry);
+        }
+        if (!fields_.isMutable()) {
+          fields_ = fields_.copy();
+        }
+        bitField0_ |= 0x00000001;
+        onChanged();
+        return fields_;
+      }
+      public int getFieldsCount() {
+        return internalGetFields().getMap().size();
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      @java.lang.Override
+      public boolean containsFields(
+          java.lang.String key) {
+        if (key == null) { throw new NullPointerException("map key"); }
+        return internalGetFields().getMap().containsKey(key);
+      }
+      /**
+       * Use {@link #getFieldsMap()} instead.
+       */
+      @java.lang.Override
+      @java.lang.Deprecated
+      public java.util.Map getFields() {
+        return getFieldsMap();
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      @java.lang.Override
+      public java.util.Map getFieldsMap() {
+        return internalGetFields().getMap();
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      @java.lang.Override
+      public /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrDefault(
+          java.lang.String key,
+          /* nullable */
+io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value defaultValue) {
+        if (key == null) { throw new NullPointerException("map key"); }
+        java.util.Map map =
+            internalGetFields().getMap();
+        return map.containsKey(key) ? map.get(key) : defaultValue;
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      @java.lang.Override
+      public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getFieldsOrThrow(
+          java.lang.String key) {
+        if (key == null) { throw new NullPointerException("map key"); }
+        java.util.Map map =
+            internalGetFields().getMap();
+        if (!map.containsKey(key)) {
+          throw new java.lang.IllegalArgumentException();
+        }
+        return map.get(key);
+      }
+      public Builder clearFields() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        internalGetMutableFields().getMutableMap()
+            .clear();
+        return this;
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      public Builder removeFields(
+          java.lang.String key) {
+        if (key == null) { throw new NullPointerException("map key"); }
+        internalGetMutableFields().getMutableMap()
+            .remove(key);
+        return this;
+      }
+      /**
+       * Use alternate mutation accessors instead.
+       */
+      @java.lang.Deprecated
+      public java.util.Map
+          getMutableFields() {
+        bitField0_ |= 0x00000001;
+        return internalGetMutableFields().getMutableMap();
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      public Builder putFields(
+          java.lang.String key,
+          io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value value) {
+        if (key == null) { throw new NullPointerException("map key"); }
+        if (value == null) { throw new NullPointerException("map value"); }
+        internalGetMutableFields().getMutableMap()
+            .put(key, value);
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * map<string, .weaviate.v1.Value> fields = 1;
+       */
+      public Builder putAllFields(
+          java.util.Map values) {
+        internalGetMutableFields().getMutableMap()
+            .putAll(values);
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:weaviate.v1.Properties)
+    }
+
+    // @@protoc_insertion_point(class_scope:weaviate.v1.Properties)
+    private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties();
+    }
+
+    public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser
+        PARSER = new com.google.protobuf.AbstractParser() {
+      @java.lang.Override
+      public Properties parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        Builder builder = newBuilder();
+        try {
+          builder.mergeFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(builder.buildPartial());
+        } catch (com.google.protobuf.UninitializedMessageException e) {
+          throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(e)
+              .setUnfinishedMessage(builder.buildPartial());
+        }
+        return builder.buildPartial();
+      }
+    };
+
+    public static com.google.protobuf.Parser parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  public interface ValueOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:weaviate.v1.Value)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * double number_value = 1;
+     * @return Whether the numberValue field is set.
+     */
+    boolean hasNumberValue();
+    /**
+     * double number_value = 1;
+     * @return The numberValue.
+     */
+    double getNumberValue();
+
+    /**
+     * 
+     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+     * 
+ * + * bool bool_value = 3; + * @return Whether the boolValue field is set. + */ + boolean hasBoolValue(); + /** + *
+     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+     * 
+ * + * bool bool_value = 3; + * @return The boolValue. + */ + boolean getBoolValue(); + + /** + * .weaviate.v1.Properties object_value = 4; + * @return Whether the objectValue field is set. + */ + boolean hasObjectValue(); + /** + * .weaviate.v1.Properties object_value = 4; + * @return The objectValue. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getObjectValue(); + /** + * .weaviate.v1.Properties object_value = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder(); + + /** + * .weaviate.v1.ListValue list_value = 5; + * @return Whether the listValue field is set. + */ + boolean hasListValue(); + /** + * .weaviate.v1.ListValue list_value = 5; + * @return The listValue. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getListValue(); + /** + * .weaviate.v1.ListValue list_value = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder(); + + /** + * string date_value = 6; + * @return Whether the dateValue field is set. + */ + boolean hasDateValue(); + /** + * string date_value = 6; + * @return The dateValue. + */ + java.lang.String getDateValue(); + /** + * string date_value = 6; + * @return The bytes for dateValue. + */ + com.google.protobuf.ByteString + getDateValueBytes(); + + /** + * string uuid_value = 7; + * @return Whether the uuidValue field is set. + */ + boolean hasUuidValue(); + /** + * string uuid_value = 7; + * @return The uuidValue. + */ + java.lang.String getUuidValue(); + /** + * string uuid_value = 7; + * @return The bytes for uuidValue. + */ + com.google.protobuf.ByteString + getUuidValueBytes(); + + /** + * int64 int_value = 8; + * @return Whether the intValue field is set. + */ + boolean hasIntValue(); + /** + * int64 int_value = 8; + * @return The intValue. + */ + long getIntValue(); + + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return Whether the geoValue field is set. + */ + boolean hasGeoValue(); + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return The geoValue. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getGeoValue(); + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder(); + + /** + * string blob_value = 10; + * @return Whether the blobValue field is set. + */ + boolean hasBlobValue(); + /** + * string blob_value = 10; + * @return The blobValue. + */ + java.lang.String getBlobValue(); + /** + * string blob_value = 10; + * @return The bytes for blobValue. + */ + com.google.protobuf.ByteString + getBlobValueBytes(); + + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return Whether the phoneValue field is set. + */ + boolean hasPhoneValue(); + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return The phoneValue. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getPhoneValue(); + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder(); + + /** + * .google.protobuf.NullValue null_value = 12; + * @return Whether the nullValue field is set. + */ + boolean hasNullValue(); + /** + * .google.protobuf.NullValue null_value = 12; + * @return The enum numeric value on the wire for nullValue. + */ + int getNullValueValue(); + /** + * .google.protobuf.NullValue null_value = 12; + * @return The nullValue. + */ + com.google.protobuf.NullValue getNullValue(); + + /** + * string text_value = 13; + * @return Whether the textValue field is set. + */ + boolean hasTextValue(); + /** + * string text_value = 13; + * @return The textValue. + */ + java.lang.String getTextValue(); + /** + * string text_value = 13; + * @return The bytes for textValue. + */ + com.google.protobuf.ByteString + getTextValueBytes(); + + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.KindCase getKindCase(); + } + /** + * Protobuf type {@code weaviate.v1.Value} + */ + public static final class Value extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.Value) + ValueOrBuilder { + private static final long serialVersionUID = 0L; + // Use Value.newBuilder() to construct. + private Value(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Value() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Value(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Value_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.Builder.class); + } + + private int kindCase_ = 0; + @SuppressWarnings("serial") + private java.lang.Object kind_; + public enum KindCase + implements com.google.protobuf.Internal.EnumLite, + com.google.protobuf.AbstractMessage.InternalOneOfEnum { + NUMBER_VALUE(1), + BOOL_VALUE(3), + OBJECT_VALUE(4), + LIST_VALUE(5), + DATE_VALUE(6), + UUID_VALUE(7), + INT_VALUE(8), + GEO_VALUE(9), + BLOB_VALUE(10), + PHONE_VALUE(11), + NULL_VALUE(12), + TEXT_VALUE(13), + KIND_NOT_SET(0); + private final int value; + private KindCase(int value) { + this.value = value; + } + /** + * @param value The number of the enum to look for. + * @return The enum associated with the given number. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static KindCase valueOf(int value) { + return forNumber(value); + } + + public static KindCase forNumber(int value) { + switch (value) { + case 1: return NUMBER_VALUE; + case 3: return BOOL_VALUE; + case 4: return OBJECT_VALUE; + case 5: return LIST_VALUE; + case 6: return DATE_VALUE; + case 7: return UUID_VALUE; + case 8: return INT_VALUE; + case 9: return GEO_VALUE; + case 10: return BLOB_VALUE; + case 11: return PHONE_VALUE; + case 12: return NULL_VALUE; + case 13: return TEXT_VALUE; + case 0: return KIND_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public KindCase + getKindCase() { + return KindCase.forNumber( + kindCase_); + } + + public static final int NUMBER_VALUE_FIELD_NUMBER = 1; + /** + * double number_value = 1; + * @return Whether the numberValue field is set. + */ + @java.lang.Override + public boolean hasNumberValue() { + return kindCase_ == 1; + } + /** + * double number_value = 1; + * @return The numberValue. + */ + @java.lang.Override + public double getNumberValue() { + if (kindCase_ == 1) { + return (java.lang.Double) kind_; + } + return 0D; + } + + public static final int BOOL_VALUE_FIELD_NUMBER = 3; + /** + *
+     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+     * 
+ * + * bool bool_value = 3; + * @return Whether the boolValue field is set. + */ + @java.lang.Override + public boolean hasBoolValue() { + return kindCase_ == 3; + } + /** + *
+     *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+     * 
+ * + * bool bool_value = 3; + * @return The boolValue. + */ + @java.lang.Override + public boolean getBoolValue() { + if (kindCase_ == 3) { + return (java.lang.Boolean) kind_; + } + return false; + } + + public static final int OBJECT_VALUE_FIELD_NUMBER = 4; + /** + * .weaviate.v1.Properties object_value = 4; + * @return Whether the objectValue field is set. + */ + @java.lang.Override + public boolean hasObjectValue() { + return kindCase_ == 4; + } + /** + * .weaviate.v1.Properties object_value = 4; + * @return The objectValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getObjectValue() { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder() { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } + + public static final int LIST_VALUE_FIELD_NUMBER = 5; + /** + * .weaviate.v1.ListValue list_value = 5; + * @return Whether the listValue field is set. + */ + @java.lang.Override + public boolean hasListValue() { + return kindCase_ == 5; + } + /** + * .weaviate.v1.ListValue list_value = 5; + * @return The listValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getListValue() { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder() { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + + public static final int DATE_VALUE_FIELD_NUMBER = 6; + /** + * string date_value = 6; + * @return Whether the dateValue field is set. + */ + public boolean hasDateValue() { + return kindCase_ == 6; + } + /** + * string date_value = 6; + * @return The dateValue. + */ + public java.lang.String getDateValue() { + java.lang.Object ref = ""; + if (kindCase_ == 6) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 6) { + kind_ = s; + } + return s; + } + } + /** + * string date_value = 6; + * @return The bytes for dateValue. + */ + public com.google.protobuf.ByteString + getDateValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 6) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 6) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int UUID_VALUE_FIELD_NUMBER = 7; + /** + * string uuid_value = 7; + * @return Whether the uuidValue field is set. + */ + public boolean hasUuidValue() { + return kindCase_ == 7; + } + /** + * string uuid_value = 7; + * @return The uuidValue. + */ + public java.lang.String getUuidValue() { + java.lang.Object ref = ""; + if (kindCase_ == 7) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 7) { + kind_ = s; + } + return s; + } + } + /** + * string uuid_value = 7; + * @return The bytes for uuidValue. + */ + public com.google.protobuf.ByteString + getUuidValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 7) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 7) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INT_VALUE_FIELD_NUMBER = 8; + /** + * int64 int_value = 8; + * @return Whether the intValue field is set. + */ + @java.lang.Override + public boolean hasIntValue() { + return kindCase_ == 8; + } + /** + * int64 int_value = 8; + * @return The intValue. + */ + @java.lang.Override + public long getIntValue() { + if (kindCase_ == 8) { + return (java.lang.Long) kind_; + } + return 0L; + } + + public static final int GEO_VALUE_FIELD_NUMBER = 9; + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return Whether the geoValue field is set. + */ + @java.lang.Override + public boolean hasGeoValue() { + return kindCase_ == 9; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return The geoValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getGeoValue() { + if (kindCase_ == 9) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder() { + if (kindCase_ == 9) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + + public static final int BLOB_VALUE_FIELD_NUMBER = 10; + /** + * string blob_value = 10; + * @return Whether the blobValue field is set. + */ + public boolean hasBlobValue() { + return kindCase_ == 10; + } + /** + * string blob_value = 10; + * @return The blobValue. + */ + public java.lang.String getBlobValue() { + java.lang.Object ref = ""; + if (kindCase_ == 10) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 10) { + kind_ = s; + } + return s; + } + } + /** + * string blob_value = 10; + * @return The bytes for blobValue. + */ + public com.google.protobuf.ByteString + getBlobValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 10) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 10) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int PHONE_VALUE_FIELD_NUMBER = 11; + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return Whether the phoneValue field is set. + */ + @java.lang.Override + public boolean hasPhoneValue() { + return kindCase_ == 11; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return The phoneValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getPhoneValue() { + if (kindCase_ == 11) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder() { + if (kindCase_ == 11) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + + public static final int NULL_VALUE_FIELD_NUMBER = 12; + /** + * .google.protobuf.NullValue null_value = 12; + * @return Whether the nullValue field is set. + */ + public boolean hasNullValue() { + return kindCase_ == 12; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @return The enum numeric value on the wire for nullValue. + */ + public int getNullValueValue() { + if (kindCase_ == 12) { + return (java.lang.Integer) kind_; + } + return 0; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @return The nullValue. + */ + public com.google.protobuf.NullValue getNullValue() { + if (kindCase_ == 12) { + com.google.protobuf.NullValue result = com.google.protobuf.NullValue.forNumber( + (java.lang.Integer) kind_); + return result == null ? com.google.protobuf.NullValue.UNRECOGNIZED : result; + } + return com.google.protobuf.NullValue.NULL_VALUE; + } + + public static final int TEXT_VALUE_FIELD_NUMBER = 13; + /** + * string text_value = 13; + * @return Whether the textValue field is set. + */ + public boolean hasTextValue() { + return kindCase_ == 13; + } + /** + * string text_value = 13; + * @return The textValue. + */ + public java.lang.String getTextValue() { + java.lang.Object ref = ""; + if (kindCase_ == 13) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 13) { + kind_ = s; + } + return s; + } + } + /** + * string text_value = 13; + * @return The bytes for textValue. + */ + public com.google.protobuf.ByteString + getTextValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 13) { + ref = kind_; + } + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 13) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (kindCase_ == 1) { + output.writeDouble( + 1, (double)((java.lang.Double) kind_)); + } + if (kindCase_ == 3) { + output.writeBool( + 3, (boolean)((java.lang.Boolean) kind_)); + } + if (kindCase_ == 4) { + output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_); + } + if (kindCase_ == 5) { + output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_); + } + if (kindCase_ == 6) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, kind_); + } + if (kindCase_ == 7) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 7, kind_); + } + if (kindCase_ == 8) { + output.writeInt64( + 8, (long)((java.lang.Long) kind_)); + } + if (kindCase_ == 9) { + output.writeMessage(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_); + } + if (kindCase_ == 10) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 10, kind_); + } + if (kindCase_ == 11) { + output.writeMessage(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_); + } + if (kindCase_ == 12) { + output.writeEnum(12, ((java.lang.Integer) kind_)); + } + if (kindCase_ == 13) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 13, kind_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (kindCase_ == 1) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize( + 1, (double)((java.lang.Double) kind_)); + } + if (kindCase_ == 3) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize( + 3, (boolean)((java.lang.Boolean) kind_)); + } + if (kindCase_ == 4) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_); + } + if (kindCase_ == 5) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_); + } + if (kindCase_ == 6) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, kind_); + } + if (kindCase_ == 7) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(7, kind_); + } + if (kindCase_ == 8) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size( + 8, (long)((java.lang.Long) kind_)); + } + if (kindCase_ == 9) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_); + } + if (kindCase_ == 10) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(10, kind_); + } + if (kindCase_ == 11) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(11, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_); + } + if (kindCase_ == 12) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(12, ((java.lang.Integer) kind_)); + } + if (kindCase_ == 13) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(13, kind_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value) obj; + + if (!getKindCase().equals(other.getKindCase())) return false; + switch (kindCase_) { + case 1: + if (java.lang.Double.doubleToLongBits(getNumberValue()) + != java.lang.Double.doubleToLongBits( + other.getNumberValue())) return false; + break; + case 3: + if (getBoolValue() + != other.getBoolValue()) return false; + break; + case 4: + if (!getObjectValue() + .equals(other.getObjectValue())) return false; + break; + case 5: + if (!getListValue() + .equals(other.getListValue())) return false; + break; + case 6: + if (!getDateValue() + .equals(other.getDateValue())) return false; + break; + case 7: + if (!getUuidValue() + .equals(other.getUuidValue())) return false; + break; + case 8: + if (getIntValue() + != other.getIntValue()) return false; + break; + case 9: + if (!getGeoValue() + .equals(other.getGeoValue())) return false; + break; + case 10: + if (!getBlobValue() + .equals(other.getBlobValue())) return false; + break; + case 11: + if (!getPhoneValue() + .equals(other.getPhoneValue())) return false; + break; + case 12: + if (getNullValueValue() + != other.getNullValueValue()) return false; + break; + case 13: + if (!getTextValue() + .equals(other.getTextValue())) return false; + break; + case 0: + default: + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + switch (kindCase_) { + case 1: + hash = (37 * hash) + NUMBER_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getNumberValue())); + break; + case 3: + hash = (37 * hash) + BOOL_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getBoolValue()); + break; + case 4: + hash = (37 * hash) + OBJECT_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getObjectValue().hashCode(); + break; + case 5: + hash = (37 * hash) + LIST_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getListValue().hashCode(); + break; + case 6: + hash = (37 * hash) + DATE_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getDateValue().hashCode(); + break; + case 7: + hash = (37 * hash) + UUID_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getUuidValue().hashCode(); + break; + case 8: + hash = (37 * hash) + INT_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getIntValue()); + break; + case 9: + hash = (37 * hash) + GEO_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getGeoValue().hashCode(); + break; + case 10: + hash = (37 * hash) + BLOB_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getBlobValue().hashCode(); + break; + case 11: + hash = (37 * hash) + PHONE_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getPhoneValue().hashCode(); + break; + case 12: + hash = (37 * hash) + NULL_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getNullValueValue(); + break; + case 13: + hash = (37 * hash) + TEXT_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getTextValue().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.Value} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.Value) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ValueOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Value_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + if (objectValueBuilder_ != null) { + objectValueBuilder_.clear(); + } + if (listValueBuilder_ != null) { + listValueBuilder_.clear(); + } + if (geoValueBuilder_ != null) { + geoValueBuilder_.clear(); + } + if (phoneValueBuilder_ != null) { + phoneValueBuilder_.clear(); + } + kindCase_ = 0; + kind_ = null; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_Value_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value(this); + if (bitField0_ != 0) { buildPartial0(result); } + buildPartialOneofs(result); + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value result) { + int from_bitField0_ = bitField0_; + } + + private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value result) { + result.kindCase_ = kindCase_; + result.kind_ = this.kind_; + if (kindCase_ == 4 && + objectValueBuilder_ != null) { + result.kind_ = objectValueBuilder_.build(); + } + if (kindCase_ == 5 && + listValueBuilder_ != null) { + result.kind_ = listValueBuilder_.build(); + } + if (kindCase_ == 9 && + geoValueBuilder_ != null) { + result.kind_ = geoValueBuilder_.build(); + } + if (kindCase_ == 11 && + phoneValueBuilder_ != null) { + result.kind_ = phoneValueBuilder_.build(); + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value.getDefaultInstance()) return this; + switch (other.getKindCase()) { + case NUMBER_VALUE: { + setNumberValue(other.getNumberValue()); + break; + } + case BOOL_VALUE: { + setBoolValue(other.getBoolValue()); + break; + } + case OBJECT_VALUE: { + mergeObjectValue(other.getObjectValue()); + break; + } + case LIST_VALUE: { + mergeListValue(other.getListValue()); + break; + } + case DATE_VALUE: { + kindCase_ = 6; + kind_ = other.kind_; + onChanged(); + break; + } + case UUID_VALUE: { + kindCase_ = 7; + kind_ = other.kind_; + onChanged(); + break; + } + case INT_VALUE: { + setIntValue(other.getIntValue()); + break; + } + case GEO_VALUE: { + mergeGeoValue(other.getGeoValue()); + break; + } + case BLOB_VALUE: { + kindCase_ = 10; + kind_ = other.kind_; + onChanged(); + break; + } + case PHONE_VALUE: { + mergePhoneValue(other.getPhoneValue()); + break; + } + case NULL_VALUE: { + setNullValueValue(other.getNullValueValue()); + break; + } + case TEXT_VALUE: { + kindCase_ = 13; + kind_ = other.kind_; + onChanged(); + break; + } + case KIND_NOT_SET: { + break; + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 9: { + kind_ = input.readDouble(); + kindCase_ = 1; + break; + } // case 9 + case 24: { + kind_ = input.readBool(); + kindCase_ = 3; + break; + } // case 24 + case 34: { + input.readMessage( + getObjectValueFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 4; + break; + } // case 34 + case 42: { + input.readMessage( + getListValueFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 5; + break; + } // case 42 + case 50: { + java.lang.String s = input.readStringRequireUtf8(); + kindCase_ = 6; + kind_ = s; + break; + } // case 50 + case 58: { + java.lang.String s = input.readStringRequireUtf8(); + kindCase_ = 7; + kind_ = s; + break; + } // case 58 + case 64: { + kind_ = input.readInt64(); + kindCase_ = 8; + break; + } // case 64 + case 74: { + input.readMessage( + getGeoValueFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 9; + break; + } // case 74 + case 82: { + java.lang.String s = input.readStringRequireUtf8(); + kindCase_ = 10; + kind_ = s; + break; + } // case 82 + case 90: { + input.readMessage( + getPhoneValueFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 11; + break; + } // case 90 + case 96: { + int rawValue = input.readEnum(); + kindCase_ = 12; + kind_ = rawValue; + break; + } // case 96 + case 106: { + java.lang.String s = input.readStringRequireUtf8(); + kindCase_ = 13; + kind_ = s; + break; + } // case 106 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int kindCase_ = 0; + private java.lang.Object kind_; + public KindCase + getKindCase() { + return KindCase.forNumber( + kindCase_); + } + + public Builder clearKind() { + kindCase_ = 0; + kind_ = null; + onChanged(); + return this; + } + + private int bitField0_; + + /** + * double number_value = 1; + * @return Whether the numberValue field is set. + */ + public boolean hasNumberValue() { + return kindCase_ == 1; + } + /** + * double number_value = 1; + * @return The numberValue. + */ + public double getNumberValue() { + if (kindCase_ == 1) { + return (java.lang.Double) kind_; + } + return 0D; + } + /** + * double number_value = 1; + * @param value The numberValue to set. + * @return This builder for chaining. + */ + public Builder setNumberValue(double value) { + + kindCase_ = 1; + kind_ = value; + onChanged(); + return this; + } + /** + * double number_value = 1; + * @return This builder for chaining. + */ + public Builder clearNumberValue() { + if (kindCase_ == 1) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + + /** + *
+       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+       * 
+ * + * bool bool_value = 3; + * @return Whether the boolValue field is set. + */ + public boolean hasBoolValue() { + return kindCase_ == 3; + } + /** + *
+       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+       * 
+ * + * bool bool_value = 3; + * @return The boolValue. + */ + public boolean getBoolValue() { + if (kindCase_ == 3) { + return (java.lang.Boolean) kind_; + } + return false; + } + /** + *
+       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+       * 
+ * + * bool bool_value = 3; + * @param value The boolValue to set. + * @return This builder for chaining. + */ + public Builder setBoolValue(boolean value) { + + kindCase_ = 3; + kind_ = value; + onChanged(); + return this; + } + /** + *
+       *dont reuse 2, old field that has been removed; Was "string string_value = 2;"
+       * 
+ * + * bool bool_value = 3; + * @return This builder for chaining. + */ + public Builder clearBoolValue() { + if (kindCase_ == 3) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> objectValueBuilder_; + /** + * .weaviate.v1.Properties object_value = 4; + * @return Whether the objectValue field is set. + */ + @java.lang.Override + public boolean hasObjectValue() { + return kindCase_ == 4; + } + /** + * .weaviate.v1.Properties object_value = 4; + * @return The objectValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getObjectValue() { + if (objectValueBuilder_ == null) { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } else { + if (kindCase_ == 4) { + return objectValueBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + public Builder setObjectValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (objectValueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + objectValueBuilder_.setMessage(value); + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + public Builder setObjectValue( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder builderForValue) { + if (objectValueBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + objectValueBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + public Builder mergeObjectValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (objectValueBuilder_ == null) { + if (kindCase_ == 4 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 4) { + objectValueBuilder_.mergeFrom(value); + } else { + objectValueBuilder_.setMessage(value); + } + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + public Builder clearObjectValue() { + if (objectValueBuilder_ == null) { + if (kindCase_ == 4) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 4) { + kindCase_ = 0; + kind_ = null; + } + objectValueBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder getObjectValueBuilder() { + return getObjectValueFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getObjectValueOrBuilder() { + if ((kindCase_ == 4) && (objectValueBuilder_ != null)) { + return objectValueBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } + } + /** + * .weaviate.v1.Properties object_value = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> + getObjectValueFieldBuilder() { + if (objectValueBuilder_ == null) { + if (!(kindCase_ == 4)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance(); + } + objectValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 4; + onChanged(); + return objectValueBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder> listValueBuilder_; + /** + * .weaviate.v1.ListValue list_value = 5; + * @return Whether the listValue field is set. + */ + @java.lang.Override + public boolean hasListValue() { + return kindCase_ == 5; + } + /** + * .weaviate.v1.ListValue list_value = 5; + * @return The listValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getListValue() { + if (listValueBuilder_ == null) { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } else { + if (kindCase_ == 5) { + return listValueBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + public Builder setListValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue value) { + if (listValueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + listValueBuilder_.setMessage(value); + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + public Builder setListValue( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder builderForValue) { + if (listValueBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + listValueBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + public Builder mergeListValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue value) { + if (listValueBuilder_ == null) { + if (kindCase_ == 5 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 5) { + listValueBuilder_.mergeFrom(value); + } else { + listValueBuilder_.setMessage(value); + } + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + public Builder clearListValue() { + if (listValueBuilder_ == null) { + if (kindCase_ == 5) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 5) { + kindCase_ = 0; + kind_ = null; + } + listValueBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder getListValueBuilder() { + return getListValueFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder getListValueOrBuilder() { + if ((kindCase_ == 5) && (listValueBuilder_ != null)) { + return listValueBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + } + /** + * .weaviate.v1.ListValue list_value = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder> + getListValueFieldBuilder() { + if (listValueBuilder_ == null) { + if (!(kindCase_ == 5)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + listValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 5; + onChanged(); + return listValueBuilder_; + } + + /** + * string date_value = 6; + * @return Whether the dateValue field is set. + */ + @java.lang.Override + public boolean hasDateValue() { + return kindCase_ == 6; + } + /** + * string date_value = 6; + * @return The dateValue. + */ + @java.lang.Override + public java.lang.String getDateValue() { + java.lang.Object ref = ""; + if (kindCase_ == 6) { + ref = kind_; + } + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 6) { + kind_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string date_value = 6; + * @return The bytes for dateValue. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getDateValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 6) { + ref = kind_; + } + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 6) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string date_value = 6; + * @param value The dateValue to set. + * @return This builder for chaining. + */ + public Builder setDateValue( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + kindCase_ = 6; + kind_ = value; + onChanged(); + return this; + } + /** + * string date_value = 6; + * @return This builder for chaining. + */ + public Builder clearDateValue() { + if (kindCase_ == 6) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + /** + * string date_value = 6; + * @param value The bytes for dateValue to set. + * @return This builder for chaining. + */ + public Builder setDateValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + kindCase_ = 6; + kind_ = value; + onChanged(); + return this; + } + + /** + * string uuid_value = 7; + * @return Whether the uuidValue field is set. + */ + @java.lang.Override + public boolean hasUuidValue() { + return kindCase_ == 7; + } + /** + * string uuid_value = 7; + * @return The uuidValue. + */ + @java.lang.Override + public java.lang.String getUuidValue() { + java.lang.Object ref = ""; + if (kindCase_ == 7) { + ref = kind_; + } + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 7) { + kind_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string uuid_value = 7; + * @return The bytes for uuidValue. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getUuidValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 7) { + ref = kind_; + } + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 7) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string uuid_value = 7; + * @param value The uuidValue to set. + * @return This builder for chaining. + */ + public Builder setUuidValue( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + kindCase_ = 7; + kind_ = value; + onChanged(); + return this; + } + /** + * string uuid_value = 7; + * @return This builder for chaining. + */ + public Builder clearUuidValue() { + if (kindCase_ == 7) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + /** + * string uuid_value = 7; + * @param value The bytes for uuidValue to set. + * @return This builder for chaining. + */ + public Builder setUuidValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + kindCase_ = 7; + kind_ = value; + onChanged(); + return this; + } + + /** + * int64 int_value = 8; + * @return Whether the intValue field is set. + */ + public boolean hasIntValue() { + return kindCase_ == 8; + } + /** + * int64 int_value = 8; + * @return The intValue. + */ + public long getIntValue() { + if (kindCase_ == 8) { + return (java.lang.Long) kind_; + } + return 0L; + } + /** + * int64 int_value = 8; + * @param value The intValue to set. + * @return This builder for chaining. + */ + public Builder setIntValue(long value) { + + kindCase_ = 8; + kind_ = value; + onChanged(); + return this; + } + /** + * int64 int_value = 8; + * @return This builder for chaining. + */ + public Builder clearIntValue() { + if (kindCase_ == 8) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder> geoValueBuilder_; + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return Whether the geoValue field is set. + */ + @java.lang.Override + public boolean hasGeoValue() { + return kindCase_ == 9; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + * @return The geoValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getGeoValue() { + if (geoValueBuilder_ == null) { + if (kindCase_ == 9) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } else { + if (kindCase_ == 9) { + return geoValueBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + public Builder setGeoValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate value) { + if (geoValueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + geoValueBuilder_.setMessage(value); + } + kindCase_ = 9; + return this; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + public Builder setGeoValue( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder builderForValue) { + if (geoValueBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + geoValueBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 9; + return this; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + public Builder mergeGeoValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate value) { + if (geoValueBuilder_ == null) { + if (kindCase_ == 9 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 9) { + geoValueBuilder_.mergeFrom(value); + } else { + geoValueBuilder_.setMessage(value); + } + } + kindCase_ = 9; + return this; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + public Builder clearGeoValue() { + if (geoValueBuilder_ == null) { + if (kindCase_ == 9) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 9) { + kindCase_ = 0; + kind_ = null; + } + geoValueBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder getGeoValueBuilder() { + return getGeoValueFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder getGeoValueOrBuilder() { + if ((kindCase_ == 9) && (geoValueBuilder_ != null)) { + return geoValueBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 9) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + } + /** + * .weaviate.v1.GeoCoordinate geo_value = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder> + getGeoValueFieldBuilder() { + if (geoValueBuilder_ == null) { + if (!(kindCase_ == 9)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + geoValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 9; + onChanged(); + return geoValueBuilder_; + } + + /** + * string blob_value = 10; + * @return Whether the blobValue field is set. + */ + @java.lang.Override + public boolean hasBlobValue() { + return kindCase_ == 10; + } + /** + * string blob_value = 10; + * @return The blobValue. + */ + @java.lang.Override + public java.lang.String getBlobValue() { + java.lang.Object ref = ""; + if (kindCase_ == 10) { + ref = kind_; + } + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 10) { + kind_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string blob_value = 10; + * @return The bytes for blobValue. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getBlobValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 10) { + ref = kind_; + } + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 10) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string blob_value = 10; + * @param value The blobValue to set. + * @return This builder for chaining. + */ + public Builder setBlobValue( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + kindCase_ = 10; + kind_ = value; + onChanged(); + return this; + } + /** + * string blob_value = 10; + * @return This builder for chaining. + */ + public Builder clearBlobValue() { + if (kindCase_ == 10) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + /** + * string blob_value = 10; + * @param value The bytes for blobValue to set. + * @return This builder for chaining. + */ + public Builder setBlobValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + kindCase_ = 10; + kind_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder> phoneValueBuilder_; + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return Whether the phoneValue field is set. + */ + @java.lang.Override + public boolean hasPhoneValue() { + return kindCase_ == 11; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + * @return The phoneValue. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getPhoneValue() { + if (phoneValueBuilder_ == null) { + if (kindCase_ == 11) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } else { + if (kindCase_ == 11) { + return phoneValueBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + public Builder setPhoneValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber value) { + if (phoneValueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + phoneValueBuilder_.setMessage(value); + } + kindCase_ = 11; + return this; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + public Builder setPhoneValue( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder builderForValue) { + if (phoneValueBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + phoneValueBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 11; + return this; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + public Builder mergePhoneValue(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber value) { + if (phoneValueBuilder_ == null) { + if (kindCase_ == 11 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 11) { + phoneValueBuilder_.mergeFrom(value); + } else { + phoneValueBuilder_.setMessage(value); + } + } + kindCase_ = 11; + return this; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + public Builder clearPhoneValue() { + if (phoneValueBuilder_ == null) { + if (kindCase_ == 11) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 11) { + kindCase_ = 0; + kind_ = null; + } + phoneValueBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder getPhoneValueBuilder() { + return getPhoneValueFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder getPhoneValueOrBuilder() { + if ((kindCase_ == 11) && (phoneValueBuilder_ != null)) { + return phoneValueBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 11) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + } + /** + * .weaviate.v1.PhoneNumber phone_value = 11; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder> + getPhoneValueFieldBuilder() { + if (phoneValueBuilder_ == null) { + if (!(kindCase_ == 11)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + phoneValueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 11; + onChanged(); + return phoneValueBuilder_; + } + + /** + * .google.protobuf.NullValue null_value = 12; + * @return Whether the nullValue field is set. + */ + @java.lang.Override + public boolean hasNullValue() { + return kindCase_ == 12; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @return The enum numeric value on the wire for nullValue. + */ + @java.lang.Override + public int getNullValueValue() { + if (kindCase_ == 12) { + return ((java.lang.Integer) kind_).intValue(); + } + return 0; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @param value The enum numeric value on the wire for nullValue to set. + * @return This builder for chaining. + */ + public Builder setNullValueValue(int value) { + kindCase_ = 12; + kind_ = value; + onChanged(); + return this; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @return The nullValue. + */ + @java.lang.Override + public com.google.protobuf.NullValue getNullValue() { + if (kindCase_ == 12) { + com.google.protobuf.NullValue result = com.google.protobuf.NullValue.forNumber( + (java.lang.Integer) kind_); + return result == null ? com.google.protobuf.NullValue.UNRECOGNIZED : result; + } + return com.google.protobuf.NullValue.NULL_VALUE; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @param value The nullValue to set. + * @return This builder for chaining. + */ + public Builder setNullValue(com.google.protobuf.NullValue value) { + if (value == null) { + throw new NullPointerException(); + } + kindCase_ = 12; + kind_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .google.protobuf.NullValue null_value = 12; + * @return This builder for chaining. + */ + public Builder clearNullValue() { + if (kindCase_ == 12) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + + /** + * string text_value = 13; + * @return Whether the textValue field is set. + */ + @java.lang.Override + public boolean hasTextValue() { + return kindCase_ == 13; + } + /** + * string text_value = 13; + * @return The textValue. + */ + @java.lang.Override + public java.lang.String getTextValue() { + java.lang.Object ref = ""; + if (kindCase_ == 13) { + ref = kind_; + } + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (kindCase_ == 13) { + kind_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string text_value = 13; + * @return The bytes for textValue. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTextValueBytes() { + java.lang.Object ref = ""; + if (kindCase_ == 13) { + ref = kind_; + } + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + if (kindCase_ == 13) { + kind_ = b; + } + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string text_value = 13; + * @param value The textValue to set. + * @return This builder for chaining. + */ + public Builder setTextValue( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + kindCase_ = 13; + kind_ = value; + onChanged(); + return this; + } + /** + * string text_value = 13; + * @return This builder for chaining. + */ + public Builder clearTextValue() { + if (kindCase_ == 13) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + return this; + } + /** + * string text_value = 13; + * @param value The bytes for textValue to set. + * @return This builder for chaining. + */ + public Builder setTextValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + kindCase_ = 13; + kind_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.Value) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.Value) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Value parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Value getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ListValueOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ListValue) + com.google.protobuf.MessageOrBuilder { + + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return Whether the numberValues field is set. + */ + boolean hasNumberValues(); + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return The numberValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getNumberValues(); + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder(); + + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return Whether the boolValues field is set. + */ + boolean hasBoolValues(); + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return The boolValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getBoolValues(); + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder(); + + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return Whether the objectValues field is set. + */ + boolean hasObjectValues(); + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return The objectValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getObjectValues(); + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder(); + + /** + * .weaviate.v1.DateValues date_values = 5; + * @return Whether the dateValues field is set. + */ + boolean hasDateValues(); + /** + * .weaviate.v1.DateValues date_values = 5; + * @return The dateValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDateValues(); + /** + * .weaviate.v1.DateValues date_values = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder(); + + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return Whether the uuidValues field is set. + */ + boolean hasUuidValues(); + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return The uuidValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getUuidValues(); + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder(); + + /** + * .weaviate.v1.IntValues int_values = 7; + * @return Whether the intValues field is set. + */ + boolean hasIntValues(); + /** + * .weaviate.v1.IntValues int_values = 7; + * @return The intValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getIntValues(); + /** + * .weaviate.v1.IntValues int_values = 7; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder(); + + /** + * .weaviate.v1.TextValues text_values = 8; + * @return Whether the textValues field is set. + */ + boolean hasTextValues(); + /** + * .weaviate.v1.TextValues text_values = 8; + * @return The textValues. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getTextValues(); + /** + * .weaviate.v1.TextValues text_values = 8; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder(); + + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.KindCase getKindCase(); + } + /** + * Protobuf type {@code weaviate.v1.ListValue} + */ + public static final class ListValue extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ListValue) + ListValueOrBuilder { + private static final long serialVersionUID = 0L; + // Use ListValue.newBuilder() to construct. + private ListValue(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ListValue() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ListValue(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder.class); + } + + private int kindCase_ = 0; + @SuppressWarnings("serial") + private java.lang.Object kind_; + public enum KindCase + implements com.google.protobuf.Internal.EnumLite, + com.google.protobuf.AbstractMessage.InternalOneOfEnum { + NUMBER_VALUES(2), + BOOL_VALUES(3), + OBJECT_VALUES(4), + DATE_VALUES(5), + UUID_VALUES(6), + INT_VALUES(7), + TEXT_VALUES(8), + KIND_NOT_SET(0); + private final int value; + private KindCase(int value) { + this.value = value; + } + /** + * @param value The number of the enum to look for. + * @return The enum associated with the given number. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static KindCase valueOf(int value) { + return forNumber(value); + } + + public static KindCase forNumber(int value) { + switch (value) { + case 2: return NUMBER_VALUES; + case 3: return BOOL_VALUES; + case 4: return OBJECT_VALUES; + case 5: return DATE_VALUES; + case 6: return UUID_VALUES; + case 7: return INT_VALUES; + case 8: return TEXT_VALUES; + case 0: return KIND_NOT_SET; + default: return null; + } + } + public int getNumber() { + return this.value; + } + }; + + public KindCase + getKindCase() { + return KindCase.forNumber( + kindCase_); + } + + public static final int NUMBER_VALUES_FIELD_NUMBER = 2; + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return Whether the numberValues field is set. + */ + @java.lang.Override + public boolean hasNumberValues() { + return kindCase_ == 2; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return The numberValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getNumberValues() { + if (kindCase_ == 2) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder() { + if (kindCase_ == 2) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + + public static final int BOOL_VALUES_FIELD_NUMBER = 3; + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return Whether the boolValues field is set. + */ + @java.lang.Override + public boolean hasBoolValues() { + return kindCase_ == 3; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return The boolValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getBoolValues() { + if (kindCase_ == 3) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder() { + if (kindCase_ == 3) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + + public static final int OBJECT_VALUES_FIELD_NUMBER = 4; + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return Whether the objectValues field is set. + */ + @java.lang.Override + public boolean hasObjectValues() { + return kindCase_ == 4; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return The objectValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getObjectValues() { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder() { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + + public static final int DATE_VALUES_FIELD_NUMBER = 5; + /** + * .weaviate.v1.DateValues date_values = 5; + * @return Whether the dateValues field is set. + */ + @java.lang.Override + public boolean hasDateValues() { + return kindCase_ == 5; + } + /** + * .weaviate.v1.DateValues date_values = 5; + * @return The dateValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDateValues() { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder() { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + + public static final int UUID_VALUES_FIELD_NUMBER = 6; + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return Whether the uuidValues field is set. + */ + @java.lang.Override + public boolean hasUuidValues() { + return kindCase_ == 6; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return The uuidValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getUuidValues() { + if (kindCase_ == 6) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder() { + if (kindCase_ == 6) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + + public static final int INT_VALUES_FIELD_NUMBER = 7; + /** + * .weaviate.v1.IntValues int_values = 7; + * @return Whether the intValues field is set. + */ + @java.lang.Override + public boolean hasIntValues() { + return kindCase_ == 7; + } + /** + * .weaviate.v1.IntValues int_values = 7; + * @return The intValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getIntValues() { + if (kindCase_ == 7) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder() { + if (kindCase_ == 7) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + + public static final int TEXT_VALUES_FIELD_NUMBER = 8; + /** + * .weaviate.v1.TextValues text_values = 8; + * @return Whether the textValues field is set. + */ + @java.lang.Override + public boolean hasTextValues() { + return kindCase_ == 8; + } + /** + * .weaviate.v1.TextValues text_values = 8; + * @return The textValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getTextValues() { + if (kindCase_ == 8) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder() { + if (kindCase_ == 8) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (kindCase_ == 2) { + output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_); + } + if (kindCase_ == 3) { + output.writeMessage(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_); + } + if (kindCase_ == 4) { + output.writeMessage(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_); + } + if (kindCase_ == 5) { + output.writeMessage(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_); + } + if (kindCase_ == 6) { + output.writeMessage(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_); + } + if (kindCase_ == 7) { + output.writeMessage(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_); + } + if (kindCase_ == 8) { + output.writeMessage(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (kindCase_ == 2) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_); + } + if (kindCase_ == 3) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_); + } + if (kindCase_ == 4) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_); + } + if (kindCase_ == 5) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_); + } + if (kindCase_ == 6) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_); + } + if (kindCase_ == 7) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_); + } + if (kindCase_ == 8) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) obj; + + if (!getKindCase().equals(other.getKindCase())) return false; + switch (kindCase_) { + case 2: + if (!getNumberValues() + .equals(other.getNumberValues())) return false; + break; + case 3: + if (!getBoolValues() + .equals(other.getBoolValues())) return false; + break; + case 4: + if (!getObjectValues() + .equals(other.getObjectValues())) return false; + break; + case 5: + if (!getDateValues() + .equals(other.getDateValues())) return false; + break; + case 6: + if (!getUuidValues() + .equals(other.getUuidValues())) return false; + break; + case 7: + if (!getIntValues() + .equals(other.getIntValues())) return false; + break; + case 8: + if (!getTextValues() + .equals(other.getTextValues())) return false; + break; + case 0: + default: + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + switch (kindCase_) { + case 2: + hash = (37 * hash) + NUMBER_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getNumberValues().hashCode(); + break; + case 3: + hash = (37 * hash) + BOOL_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getBoolValues().hashCode(); + break; + case 4: + hash = (37 * hash) + OBJECT_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getObjectValues().hashCode(); + break; + case 5: + hash = (37 * hash) + DATE_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getDateValues().hashCode(); + break; + case 6: + hash = (37 * hash) + UUID_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getUuidValues().hashCode(); + break; + case 7: + hash = (37 * hash) + INT_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getIntValues().hashCode(); + break; + case 8: + hash = (37 * hash) + TEXT_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getTextValues().hashCode(); + break; + case 0: + default: + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ListValue} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ListValue) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValueOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + if (numberValuesBuilder_ != null) { + numberValuesBuilder_.clear(); + } + if (boolValuesBuilder_ != null) { + boolValuesBuilder_.clear(); + } + if (objectValuesBuilder_ != null) { + objectValuesBuilder_.clear(); + } + if (dateValuesBuilder_ != null) { + dateValuesBuilder_.clear(); + } + if (uuidValuesBuilder_ != null) { + uuidValuesBuilder_.clear(); + } + if (intValuesBuilder_ != null) { + intValuesBuilder_.clear(); + } + if (textValuesBuilder_ != null) { + textValuesBuilder_.clear(); + } + kindCase_ = 0; + kind_ = null; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ListValue_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue(this); + if (bitField0_ != 0) { buildPartial0(result); } + buildPartialOneofs(result); + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue result) { + int from_bitField0_ = bitField0_; + } + + private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue result) { + result.kindCase_ = kindCase_; + result.kind_ = this.kind_; + if (kindCase_ == 2 && + numberValuesBuilder_ != null) { + result.kind_ = numberValuesBuilder_.build(); + } + if (kindCase_ == 3 && + boolValuesBuilder_ != null) { + result.kind_ = boolValuesBuilder_.build(); + } + if (kindCase_ == 4 && + objectValuesBuilder_ != null) { + result.kind_ = objectValuesBuilder_.build(); + } + if (kindCase_ == 5 && + dateValuesBuilder_ != null) { + result.kind_ = dateValuesBuilder_.build(); + } + if (kindCase_ == 6 && + uuidValuesBuilder_ != null) { + result.kind_ = uuidValuesBuilder_.build(); + } + if (kindCase_ == 7 && + intValuesBuilder_ != null) { + result.kind_ = intValuesBuilder_.build(); + } + if (kindCase_ == 8 && + textValuesBuilder_ != null) { + result.kind_ = textValuesBuilder_.build(); + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue.getDefaultInstance()) return this; + switch (other.getKindCase()) { + case NUMBER_VALUES: { + mergeNumberValues(other.getNumberValues()); + break; + } + case BOOL_VALUES: { + mergeBoolValues(other.getBoolValues()); + break; + } + case OBJECT_VALUES: { + mergeObjectValues(other.getObjectValues()); + break; + } + case DATE_VALUES: { + mergeDateValues(other.getDateValues()); + break; + } + case UUID_VALUES: { + mergeUuidValues(other.getUuidValues()); + break; + } + case INT_VALUES: { + mergeIntValues(other.getIntValues()); + break; + } + case TEXT_VALUES: { + mergeTextValues(other.getTextValues()); + break; + } + case KIND_NOT_SET: { + break; + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 18: { + input.readMessage( + getNumberValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 2; + break; + } // case 18 + case 26: { + input.readMessage( + getBoolValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 3; + break; + } // case 26 + case 34: { + input.readMessage( + getObjectValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 4; + break; + } // case 34 + case 42: { + input.readMessage( + getDateValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 5; + break; + } // case 42 + case 50: { + input.readMessage( + getUuidValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 6; + break; + } // case 50 + case 58: { + input.readMessage( + getIntValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 7; + break; + } // case 58 + case 66: { + input.readMessage( + getTextValuesFieldBuilder().getBuilder(), + extensionRegistry); + kindCase_ = 8; + break; + } // case 66 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int kindCase_ = 0; + private java.lang.Object kind_; + public KindCase + getKindCase() { + return KindCase.forNumber( + kindCase_); + } + + public Builder clearKind() { + kindCase_ = 0; + kind_ = null; + onChanged(); + return this; + } + + private int bitField0_; + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder> numberValuesBuilder_; + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return Whether the numberValues field is set. + */ + @java.lang.Override + public boolean hasNumberValues() { + return kindCase_ == 2; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + * @return The numberValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getNumberValues() { + if (numberValuesBuilder_ == null) { + if (kindCase_ == 2) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } else { + if (kindCase_ == 2) { + return numberValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + public Builder setNumberValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues value) { + if (numberValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + numberValuesBuilder_.setMessage(value); + } + kindCase_ = 2; + return this; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + public Builder setNumberValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder builderForValue) { + if (numberValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + numberValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 2; + return this; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + public Builder mergeNumberValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues value) { + if (numberValuesBuilder_ == null) { + if (kindCase_ == 2 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 2) { + numberValuesBuilder_.mergeFrom(value); + } else { + numberValuesBuilder_.setMessage(value); + } + } + kindCase_ = 2; + return this; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + public Builder clearNumberValues() { + if (numberValuesBuilder_ == null) { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 2) { + kindCase_ = 0; + kind_ = null; + } + numberValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder getNumberValuesBuilder() { + return getNumberValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder getNumberValuesOrBuilder() { + if ((kindCase_ == 2) && (numberValuesBuilder_ != null)) { + return numberValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 2) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.NumberValues number_values = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder> + getNumberValuesFieldBuilder() { + if (numberValuesBuilder_ == null) { + if (!(kindCase_ == 2)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + numberValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 2; + onChanged(); + return numberValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder> boolValuesBuilder_; + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return Whether the boolValues field is set. + */ + @java.lang.Override + public boolean hasBoolValues() { + return kindCase_ == 3; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + * @return The boolValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getBoolValues() { + if (boolValuesBuilder_ == null) { + if (kindCase_ == 3) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } else { + if (kindCase_ == 3) { + return boolValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + public Builder setBoolValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues value) { + if (boolValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + boolValuesBuilder_.setMessage(value); + } + kindCase_ = 3; + return this; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + public Builder setBoolValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder builderForValue) { + if (boolValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + boolValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 3; + return this; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + public Builder mergeBoolValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues value) { + if (boolValuesBuilder_ == null) { + if (kindCase_ == 3 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 3) { + boolValuesBuilder_.mergeFrom(value); + } else { + boolValuesBuilder_.setMessage(value); + } + } + kindCase_ = 3; + return this; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + public Builder clearBoolValues() { + if (boolValuesBuilder_ == null) { + if (kindCase_ == 3) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 3) { + kindCase_ = 0; + kind_ = null; + } + boolValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder getBoolValuesBuilder() { + return getBoolValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder getBoolValuesOrBuilder() { + if ((kindCase_ == 3) && (boolValuesBuilder_ != null)) { + return boolValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 3) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.BoolValues bool_values = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder> + getBoolValuesFieldBuilder() { + if (boolValuesBuilder_ == null) { + if (!(kindCase_ == 3)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + boolValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 3; + onChanged(); + return boolValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder> objectValuesBuilder_; + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return Whether the objectValues field is set. + */ + @java.lang.Override + public boolean hasObjectValues() { + return kindCase_ == 4; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + * @return The objectValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getObjectValues() { + if (objectValuesBuilder_ == null) { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } else { + if (kindCase_ == 4) { + return objectValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + public Builder setObjectValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues value) { + if (objectValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + objectValuesBuilder_.setMessage(value); + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + public Builder setObjectValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder builderForValue) { + if (objectValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + objectValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + public Builder mergeObjectValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues value) { + if (objectValuesBuilder_ == null) { + if (kindCase_ == 4 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 4) { + objectValuesBuilder_.mergeFrom(value); + } else { + objectValuesBuilder_.setMessage(value); + } + } + kindCase_ = 4; + return this; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + public Builder clearObjectValues() { + if (objectValuesBuilder_ == null) { + if (kindCase_ == 4) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 4) { + kindCase_ = 0; + kind_ = null; + } + objectValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder getObjectValuesBuilder() { + return getObjectValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder getObjectValuesOrBuilder() { + if ((kindCase_ == 4) && (objectValuesBuilder_ != null)) { + return objectValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 4) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.ObjectValues object_values = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder> + getObjectValuesFieldBuilder() { + if (objectValuesBuilder_ == null) { + if (!(kindCase_ == 4)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + objectValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 4; + onChanged(); + return objectValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder> dateValuesBuilder_; + /** + * .weaviate.v1.DateValues date_values = 5; + * @return Whether the dateValues field is set. + */ + @java.lang.Override + public boolean hasDateValues() { + return kindCase_ == 5; + } + /** + * .weaviate.v1.DateValues date_values = 5; + * @return The dateValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDateValues() { + if (dateValuesBuilder_ == null) { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } else { + if (kindCase_ == 5) { + return dateValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + public Builder setDateValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues value) { + if (dateValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + dateValuesBuilder_.setMessage(value); + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + public Builder setDateValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder builderForValue) { + if (dateValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + dateValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + public Builder mergeDateValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues value) { + if (dateValuesBuilder_ == null) { + if (kindCase_ == 5 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 5) { + dateValuesBuilder_.mergeFrom(value); + } else { + dateValuesBuilder_.setMessage(value); + } + } + kindCase_ = 5; + return this; + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + public Builder clearDateValues() { + if (dateValuesBuilder_ == null) { + if (kindCase_ == 5) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 5) { + kindCase_ = 0; + kind_ = null; + } + dateValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder getDateValuesBuilder() { + return getDateValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder getDateValuesOrBuilder() { + if ((kindCase_ == 5) && (dateValuesBuilder_ != null)) { + return dateValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 5) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.DateValues date_values = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder> + getDateValuesFieldBuilder() { + if (dateValuesBuilder_ == null) { + if (!(kindCase_ == 5)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + dateValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 5; + onChanged(); + return dateValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder> uuidValuesBuilder_; + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return Whether the uuidValues field is set. + */ + @java.lang.Override + public boolean hasUuidValues() { + return kindCase_ == 6; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + * @return The uuidValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getUuidValues() { + if (uuidValuesBuilder_ == null) { + if (kindCase_ == 6) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } else { + if (kindCase_ == 6) { + return uuidValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + public Builder setUuidValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues value) { + if (uuidValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + uuidValuesBuilder_.setMessage(value); + } + kindCase_ = 6; + return this; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + public Builder setUuidValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder builderForValue) { + if (uuidValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + uuidValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 6; + return this; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + public Builder mergeUuidValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues value) { + if (uuidValuesBuilder_ == null) { + if (kindCase_ == 6 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 6) { + uuidValuesBuilder_.mergeFrom(value); + } else { + uuidValuesBuilder_.setMessage(value); + } + } + kindCase_ = 6; + return this; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + public Builder clearUuidValues() { + if (uuidValuesBuilder_ == null) { + if (kindCase_ == 6) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 6) { + kindCase_ = 0; + kind_ = null; + } + uuidValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder getUuidValuesBuilder() { + return getUuidValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder getUuidValuesOrBuilder() { + if ((kindCase_ == 6) && (uuidValuesBuilder_ != null)) { + return uuidValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 6) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.UuidValues uuid_values = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder> + getUuidValuesFieldBuilder() { + if (uuidValuesBuilder_ == null) { + if (!(kindCase_ == 6)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + uuidValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 6; + onChanged(); + return uuidValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder> intValuesBuilder_; + /** + * .weaviate.v1.IntValues int_values = 7; + * @return Whether the intValues field is set. + */ + @java.lang.Override + public boolean hasIntValues() { + return kindCase_ == 7; + } + /** + * .weaviate.v1.IntValues int_values = 7; + * @return The intValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getIntValues() { + if (intValuesBuilder_ == null) { + if (kindCase_ == 7) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } else { + if (kindCase_ == 7) { + return intValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + public Builder setIntValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues value) { + if (intValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + intValuesBuilder_.setMessage(value); + } + kindCase_ = 7; + return this; + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + public Builder setIntValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder builderForValue) { + if (intValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + intValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 7; + return this; + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + public Builder mergeIntValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues value) { + if (intValuesBuilder_ == null) { + if (kindCase_ == 7 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 7) { + intValuesBuilder_.mergeFrom(value); + } else { + intValuesBuilder_.setMessage(value); + } + } + kindCase_ = 7; + return this; + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + public Builder clearIntValues() { + if (intValuesBuilder_ == null) { + if (kindCase_ == 7) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 7) { + kindCase_ = 0; + kind_ = null; + } + intValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder getIntValuesBuilder() { + return getIntValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder getIntValuesOrBuilder() { + if ((kindCase_ == 7) && (intValuesBuilder_ != null)) { + return intValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 7) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.IntValues int_values = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder> + getIntValuesFieldBuilder() { + if (intValuesBuilder_ == null) { + if (!(kindCase_ == 7)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + intValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 7; + onChanged(); + return intValuesBuilder_; + } + + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder> textValuesBuilder_; + /** + * .weaviate.v1.TextValues text_values = 8; + * @return Whether the textValues field is set. + */ + @java.lang.Override + public boolean hasTextValues() { + return kindCase_ == 8; + } + /** + * .weaviate.v1.TextValues text_values = 8; + * @return The textValues. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getTextValues() { + if (textValuesBuilder_ == null) { + if (kindCase_ == 8) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } else { + if (kindCase_ == 8) { + return textValuesBuilder_.getMessage(); + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + public Builder setTextValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues value) { + if (textValuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + kind_ = value; + onChanged(); + } else { + textValuesBuilder_.setMessage(value); + } + kindCase_ = 8; + return this; + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + public Builder setTextValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder builderForValue) { + if (textValuesBuilder_ == null) { + kind_ = builderForValue.build(); + onChanged(); + } else { + textValuesBuilder_.setMessage(builderForValue.build()); + } + kindCase_ = 8; + return this; + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + public Builder mergeTextValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues value) { + if (textValuesBuilder_ == null) { + if (kindCase_ == 8 && + kind_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance()) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_) + .mergeFrom(value).buildPartial(); + } else { + kind_ = value; + } + onChanged(); + } else { + if (kindCase_ == 8) { + textValuesBuilder_.mergeFrom(value); + } else { + textValuesBuilder_.setMessage(value); + } + } + kindCase_ = 8; + return this; + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + public Builder clearTextValues() { + if (textValuesBuilder_ == null) { + if (kindCase_ == 8) { + kindCase_ = 0; + kind_ = null; + onChanged(); + } + } else { + if (kindCase_ == 8) { + kindCase_ = 0; + kind_ = null; + } + textValuesBuilder_.clear(); + } + return this; + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder getTextValuesBuilder() { + return getTextValuesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder getTextValuesOrBuilder() { + if ((kindCase_ == 8) && (textValuesBuilder_ != null)) { + return textValuesBuilder_.getMessageOrBuilder(); + } else { + if (kindCase_ == 8) { + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_; + } + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + } + /** + * .weaviate.v1.TextValues text_values = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder> + getTextValuesFieldBuilder() { + if (textValuesBuilder_ == null) { + if (!(kindCase_ == 8)) { + kind_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + textValuesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) kind_, + getParentForChildren(), + isClean()); + kind_ = null; + } + kindCase_ = 8; + onChanged(); + return textValuesBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ListValue) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ListValue) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ListValue parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ListValue getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface NumberValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.NumberValues) + com.google.protobuf.MessageOrBuilder { + + /** + *
+     **
+     * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+     * The byte array is stored in little-endian order using uint64 encoding.
+     * 
+ * + * bytes values = 1; + * @return The values. + */ + com.google.protobuf.ByteString getValues(); + } + /** + * Protobuf type {@code weaviate.v1.NumberValues} + */ + public static final class NumberValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.NumberValues) + NumberValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use NumberValues.newBuilder() to construct. + private NumberValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private NumberValues() { + values_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new NumberValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+     **
+     * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+     * The byte array is stored in little-endian order using uint64 encoding.
+     * 
+ * + * bytes values = 1; + * @return The values. + */ + @java.lang.Override + public com.google.protobuf.ByteString getValues() { + return values_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!values_.isEmpty()) { + output.writeBytes(1, values_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!values_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, values_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) obj; + + if (!getValues() + .equals(other.getValues())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValues().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.NumberValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.NumberValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = com.google.protobuf.ByteString.EMPTY; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_NumberValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues.getDefaultInstance()) return this; + if (other.getValues() != com.google.protobuf.ByteString.EMPTY) { + setValues(other.getValues()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + values_ = input.readBytes(); + bitField0_ |= 0x00000001; + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @return The values. + */ + @java.lang.Override + public com.google.protobuf.ByteString getValues() { + return values_; + } + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + values_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single float64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + bitField0_ = (bitField0_ & ~0x00000001); + values_ = getDefaultInstance().getValues(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.NumberValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.NumberValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public NumberValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.NumberValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface TextValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.TextValues) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string values = 1; + * @return A list containing the values. + */ + java.util.List + getValuesList(); + /** + * repeated string values = 1; + * @return The count of values. + */ + int getValuesCount(); + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + java.lang.String getValues(int index); + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + com.google.protobuf.ByteString + getValuesBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.TextValues} + */ + public static final class TextValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.TextValues) + TextValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use TextValues.newBuilder() to construct. + private TextValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private TextValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new TextValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < values_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < values_.size(); i++) { + dataSize += computeStringSizeNoTag(values_.getRaw(i)); + } + size += dataSize; + size += 1 * getValuesList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) obj; + + if (!getValuesList() + .equals(other.getValuesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValuesCount() > 0) { + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValuesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.TextValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.TextValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_TextValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + values_.makeImmutable(); + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues.getDefaultInstance()) return this; + if (!other.values_.isEmpty()) { + if (values_.isEmpty()) { + values_ = other.values_; + bitField0_ |= 0x00000001; + } else { + ensureValuesIsMutable(); + values_.addAll(other.values_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureValuesIsMutable(); + values_.add(s); + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureValuesIsMutable() { + if (!values_.isModifiable()) { + values_ = new com.google.protobuf.LazyStringArrayList(values_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + values_.makeImmutable(); + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + /** + * repeated string values = 1; + * @param index The index to set the value at. + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The values to add. + * @return This builder for chaining. + */ + public Builder addValues( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param values The values to add. + * @return This builder for chaining. + */ + public Builder addAllValues( + java.lang.Iterable values) { + ensureValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, values_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The bytes of the values to add. + * @return This builder for chaining. + */ + public Builder addValuesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.TextValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.TextValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public TextValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.TextValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface BoolValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.BoolValues) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated bool values = 1; + * @return A list containing the values. + */ + java.util.List getValuesList(); + /** + * repeated bool values = 1; + * @return The count of values. + */ + int getValuesCount(); + /** + * repeated bool values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + boolean getValues(int index); + } + /** + * Protobuf type {@code weaviate.v1.BoolValues} + */ + public static final class BoolValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.BoolValues) + BoolValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use BoolValues.newBuilder() to construct. + private BoolValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BoolValues() { + values_ = emptyBooleanList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new BoolValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.Internal.BooleanList values_ = + emptyBooleanList(); + /** + * repeated bool values = 1; + * @return A list containing the values. + */ + @java.lang.Override + public java.util.List + getValuesList() { + return values_; + } + /** + * repeated bool values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated bool values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public boolean getValues(int index) { + return values_.getBoolean(index); + } + private int valuesMemoizedSerializedSize = -1; + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (getValuesList().size() > 0) { + output.writeUInt32NoTag(10); + output.writeUInt32NoTag(valuesMemoizedSerializedSize); + } + for (int i = 0; i < values_.size(); i++) { + output.writeBoolNoTag(values_.getBoolean(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + dataSize = 1 * getValuesList().size(); + size += dataSize; + if (!getValuesList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + valuesMemoizedSerializedSize = dataSize; + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) obj; + + if (!getValuesList() + .equals(other.getValuesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValuesCount() > 0) { + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValuesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.BoolValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.BoolValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = emptyBooleanList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_BoolValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + values_.makeImmutable(); + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues.getDefaultInstance()) return this; + if (!other.values_.isEmpty()) { + if (values_.isEmpty()) { + values_ = other.values_; + values_.makeImmutable(); + bitField0_ |= 0x00000001; + } else { + ensureValuesIsMutable(); + values_.addAll(other.values_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + boolean v = input.readBool(); + ensureValuesIsMutable(); + values_.addBoolean(v); + break; + } // case 8 + case 10: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + int alloc = length > 4096 ? 4096 : length; + ensureValuesIsMutable(alloc / 1); + while (input.getBytesUntilLimit() > 0) { + values_.addBoolean(input.readBool()); + } + input.popLimit(limit); + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.Internal.BooleanList values_ = emptyBooleanList(); + private void ensureValuesIsMutable() { + if (!values_.isModifiable()) { + values_ = makeMutableCopy(values_); + } + bitField0_ |= 0x00000001; + } + private void ensureValuesIsMutable(int capacity) { + if (!values_.isModifiable()) { + values_ = makeMutableCopy(values_, capacity); + } + bitField0_ |= 0x00000001; + } + /** + * repeated bool values = 1; + * @return A list containing the values. + */ + public java.util.List + getValuesList() { + values_.makeImmutable(); + return values_; + } + /** + * repeated bool values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated bool values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public boolean getValues(int index) { + return values_.getBoolean(index); + } + /** + * repeated bool values = 1; + * @param index The index to set the value at. + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues( + int index, boolean value) { + + ensureValuesIsMutable(); + values_.setBoolean(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated bool values = 1; + * @param value The values to add. + * @return This builder for chaining. + */ + public Builder addValues(boolean value) { + + ensureValuesIsMutable(); + values_.addBoolean(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated bool values = 1; + * @param values The values to add. + * @return This builder for chaining. + */ + public Builder addAllValues( + java.lang.Iterable values) { + ensureValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, values_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated bool values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + values_ = emptyBooleanList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.BoolValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.BoolValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public BoolValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.BoolValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ObjectValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ObjectValues) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .weaviate.v1.Properties values = 1; + */ + java.util.List + getValuesList(); + /** + * repeated .weaviate.v1.Properties values = 1; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getValues(int index); + /** + * repeated .weaviate.v1.Properties values = 1; + */ + int getValuesCount(); + /** + * repeated .weaviate.v1.Properties values = 1; + */ + java.util.List + getValuesOrBuilderList(); + /** + * repeated .weaviate.v1.Properties values = 1; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.ObjectValues} + */ + public static final class ObjectValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ObjectValues) + ObjectValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use ObjectValues.newBuilder() to construct. + private ObjectValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ObjectValues() { + values_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ObjectValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private java.util.List values_; + /** + * repeated .weaviate.v1.Properties values = 1; + */ + @java.lang.Override + public java.util.List getValuesList() { + return values_; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + @java.lang.Override + public java.util.List + getValuesOrBuilderList() { + return values_; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + @java.lang.Override + public int getValuesCount() { + return values_.size(); + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getValues(int index) { + return values_.get(index); + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( + int index) { + return values_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < values_.size(); i++) { + output.writeMessage(1, values_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < values_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, values_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) obj; + + if (!getValuesList() + .equals(other.getValuesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValuesCount() > 0) { + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValuesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ObjectValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + if (valuesBuilder_ == null) { + values_ = java.util.Collections.emptyList(); + } else { + values_ = null; + valuesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_ObjectValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues result) { + if (valuesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + values_ = java.util.Collections.unmodifiableList(values_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.values_ = values_; + } else { + result.values_ = valuesBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues result) { + int from_bitField0_ = bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues.getDefaultInstance()) return this; + if (valuesBuilder_ == null) { + if (!other.values_.isEmpty()) { + if (values_.isEmpty()) { + values_ = other.values_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureValuesIsMutable(); + values_.addAll(other.values_); + } + onChanged(); + } + } else { + if (!other.values_.isEmpty()) { + if (valuesBuilder_.isEmpty()) { + valuesBuilder_.dispose(); + valuesBuilder_ = null; + values_ = other.values_; + bitField0_ = (bitField0_ & ~0x00000001); + valuesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getValuesFieldBuilder() : null; + } else { + valuesBuilder_.addAllMessages(other.values_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.parser(), + extensionRegistry); + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + values_.add(m); + } else { + valuesBuilder_.addMessage(m); + } + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.util.List values_ = + java.util.Collections.emptyList(); + private void ensureValuesIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + values_ = new java.util.ArrayList(values_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> valuesBuilder_; + + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public java.util.List getValuesList() { + if (valuesBuilder_ == null) { + return java.util.Collections.unmodifiableList(values_); + } else { + return valuesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public int getValuesCount() { + if (valuesBuilder_ == null) { + return values_.size(); + } else { + return valuesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getValues(int index) { + if (valuesBuilder_ == null) { + return values_.get(index); + } else { + return valuesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder setValues( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (valuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValuesIsMutable(); + values_.set(index, value); + onChanged(); + } else { + valuesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder setValues( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder builderForValue) { + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + values_.set(index, builderForValue.build()); + onChanged(); + } else { + valuesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder addValues(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (valuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValuesIsMutable(); + values_.add(value); + onChanged(); + } else { + valuesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder addValues( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (valuesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValuesIsMutable(); + values_.add(index, value); + onChanged(); + } else { + valuesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder addValues( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder builderForValue) { + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + values_.add(builderForValue.build()); + onChanged(); + } else { + valuesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder addValues( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder builderForValue) { + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + values_.add(index, builderForValue.build()); + onChanged(); + } else { + valuesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder addAllValues( + java.lang.Iterable values) { + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, values_); + onChanged(); + } else { + valuesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder clearValues() { + if (valuesBuilder_ == null) { + values_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + valuesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public Builder removeValues(int index) { + if (valuesBuilder_ == null) { + ensureValuesIsMutable(); + values_.remove(index); + onChanged(); + } else { + valuesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder getValuesBuilder( + int index) { + return getValuesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getValuesOrBuilder( + int index) { + if (valuesBuilder_ == null) { + return values_.get(index); } else { + return valuesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public java.util.List + getValuesOrBuilderList() { + if (valuesBuilder_ != null) { + return valuesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(values_); + } + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder addValuesBuilder() { + return getValuesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder addValuesBuilder( + int index) { + return getValuesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.Properties values = 1; + */ + public java.util.List + getValuesBuilderList() { + return getValuesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> + getValuesFieldBuilder() { + if (valuesBuilder_ == null) { + valuesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder>( + values_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + values_ = null; + } + return valuesBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ObjectValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ObjectValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.ObjectValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DateValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.DateValues) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string values = 1; + * @return A list containing the values. + */ + java.util.List + getValuesList(); + /** + * repeated string values = 1; + * @return The count of values. + */ + int getValuesCount(); + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + java.lang.String getValues(int index); + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + com.google.protobuf.ByteString + getValuesBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.DateValues} + */ + public static final class DateValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.DateValues) + DateValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use DateValues.newBuilder() to construct. + private DateValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private DateValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new DateValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < values_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < values_.size(); i++) { + dataSize += computeStringSizeNoTag(values_.getRaw(i)); + } + size += dataSize; + size += 1 * getValuesList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) obj; + + if (!getValuesList() + .equals(other.getValuesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValuesCount() > 0) { + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValuesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.DateValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.DateValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_DateValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + values_.makeImmutable(); + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues.getDefaultInstance()) return this; + if (!other.values_.isEmpty()) { + if (values_.isEmpty()) { + values_ = other.values_; + bitField0_ |= 0x00000001; + } else { + ensureValuesIsMutable(); + values_.addAll(other.values_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureValuesIsMutable(); + values_.add(s); + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureValuesIsMutable() { + if (!values_.isModifiable()) { + values_ = new com.google.protobuf.LazyStringArrayList(values_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + values_.makeImmutable(); + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + /** + * repeated string values = 1; + * @param index The index to set the value at. + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The values to add. + * @return This builder for chaining. + */ + public Builder addValues( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param values The values to add. + * @return This builder for chaining. + */ + public Builder addAllValues( + java.lang.Iterable values) { + ensureValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, values_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The bytes of the values to add. + * @return This builder for chaining. + */ + public Builder addValuesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.DateValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.DateValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public DateValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.DateValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface UuidValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.UuidValues) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string values = 1; + * @return A list containing the values. + */ + java.util.List + getValuesList(); + /** + * repeated string values = 1; + * @return The count of values. + */ + int getValuesCount(); + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + java.lang.String getValues(int index); + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + com.google.protobuf.ByteString + getValuesBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.UuidValues} + */ + public static final class UuidValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.UuidValues) + UuidValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use UuidValues.newBuilder() to construct. + private UuidValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private UuidValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new UuidValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < values_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, values_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < values_.size(); i++) { + dataSize += computeStringSizeNoTag(values_.getRaw(i)); + } + size += dataSize; + size += 1 * getValuesList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) obj; + + if (!getValuesList() + .equals(other.getValuesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValuesCount() > 0) { + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValuesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.UuidValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.UuidValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_UuidValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + values_.makeImmutable(); + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues.getDefaultInstance()) return this; + if (!other.values_.isEmpty()) { + if (values_.isEmpty()) { + values_ = other.values_; + bitField0_ |= 0x00000001; + } else { + ensureValuesIsMutable(); + values_.addAll(other.values_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureValuesIsMutable(); + values_.add(s); + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureValuesIsMutable() { + if (!values_.isModifiable()) { + values_ = new com.google.protobuf.LazyStringArrayList(values_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string values = 1; + * @return A list containing the values. + */ + public com.google.protobuf.ProtocolStringList + getValuesList() { + values_.makeImmutable(); + return values_; + } + /** + * repeated string values = 1; + * @return The count of values. + */ + public int getValuesCount() { + return values_.size(); + } + /** + * repeated string values = 1; + * @param index The index of the element to return. + * @return The values at the given index. + */ + public java.lang.String getValues(int index) { + return values_.get(index); + } + /** + * repeated string values = 1; + * @param index The index of the value to return. + * @return The bytes of the values at the given index. + */ + public com.google.protobuf.ByteString + getValuesBytes(int index) { + return values_.getByteString(index); + } + /** + * repeated string values = 1; + * @param index The index to set the value at. + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The values to add. + * @return This builder for chaining. + */ + public Builder addValues( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param values The values to add. + * @return This builder for chaining. + */ + public Builder addAllValues( + java.lang.Iterable values) { + ensureValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, values_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + values_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string values = 1; + * @param value The bytes of the values to add. + * @return This builder for chaining. + */ + public Builder addValuesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureValuesIsMutable(); + values_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.UuidValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.UuidValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public UuidValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.UuidValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface IntValuesOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.IntValues) + com.google.protobuf.MessageOrBuilder { + + /** + *
+     **
+     * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+     * The byte array is stored in little-endian order using uint64 encoding.
+     * 
+ * + * bytes values = 1; + * @return The values. + */ + com.google.protobuf.ByteString getValues(); + } + /** + * Protobuf type {@code weaviate.v1.IntValues} + */ + public static final class IntValues extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.IntValues) + IntValuesOrBuilder { + private static final long serialVersionUID = 0L; + // Use IntValues.newBuilder() to construct. + private IntValues(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private IntValues() { + values_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new IntValues(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder.class); + } + + public static final int VALUES_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+     **
+     * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+     * The byte array is stored in little-endian order using uint64 encoding.
+     * 
+ * + * bytes values = 1; + * @return The values. + */ + @java.lang.Override + public com.google.protobuf.ByteString getValues() { + return values_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!values_.isEmpty()) { + output.writeBytes(1, values_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!values_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, values_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) obj; + + if (!getValues() + .equals(other.getValues())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + VALUES_FIELD_NUMBER; + hash = (53 * hash) + getValues().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.IntValues} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.IntValues) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValuesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + values_ = com.google.protobuf.ByteString.EMPTY; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_IntValues_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.values_ = values_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues.getDefaultInstance()) return this; + if (other.getValues() != com.google.protobuf.ByteString.EMPTY) { + setValues(other.getValues()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + values_ = input.readBytes(); + bitField0_ |= 0x00000001; + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString values_ = com.google.protobuf.ByteString.EMPTY; + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @return The values. + */ + @java.lang.Override + public com.google.protobuf.ByteString getValues() { + return values_; + } + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @param value The values to set. + * @return This builder for chaining. + */ + public Builder setValues(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + values_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       **
+       * The values are stored as a byte array, where each 8 bytes represent a single int64 value.
+       * The byte array is stored in little-endian order using uint64 encoding.
+       * 
+ * + * bytes values = 1; + * @return This builder for chaining. + */ + public Builder clearValues() { + bitField0_ = (bitField0_ & ~0x00000001); + values_ = getDefaultInstance().getValues(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.IntValues) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.IntValues) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public IntValues parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.IntValues getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GeoCoordinateOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.GeoCoordinate) + com.google.protobuf.MessageOrBuilder { + + /** + * float longitude = 1; + * @return The longitude. + */ + float getLongitude(); + + /** + * float latitude = 2; + * @return The latitude. + */ + float getLatitude(); + } + /** + * Protobuf type {@code weaviate.v1.GeoCoordinate} + */ + public static final class GeoCoordinate extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.GeoCoordinate) + GeoCoordinateOrBuilder { + private static final long serialVersionUID = 0L; + // Use GeoCoordinate.newBuilder() to construct. + private GeoCoordinate(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GeoCoordinate() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GeoCoordinate(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder.class); + } + + public static final int LONGITUDE_FIELD_NUMBER = 1; + private float longitude_ = 0F; + /** + * float longitude = 1; + * @return The longitude. + */ + @java.lang.Override + public float getLongitude() { + return longitude_; + } + + public static final int LATITUDE_FIELD_NUMBER = 2; + private float latitude_ = 0F; + /** + * float latitude = 2; + * @return The latitude. + */ + @java.lang.Override + public float getLatitude() { + return latitude_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (java.lang.Float.floatToRawIntBits(longitude_) != 0) { + output.writeFloat(1, longitude_); + } + if (java.lang.Float.floatToRawIntBits(latitude_) != 0) { + output.writeFloat(2, latitude_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (java.lang.Float.floatToRawIntBits(longitude_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(1, longitude_); + } + if (java.lang.Float.floatToRawIntBits(latitude_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(2, latitude_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) obj; + + if (java.lang.Float.floatToIntBits(getLongitude()) + != java.lang.Float.floatToIntBits( + other.getLongitude())) return false; + if (java.lang.Float.floatToIntBits(getLatitude()) + != java.lang.Float.floatToIntBits( + other.getLatitude())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + LONGITUDE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getLongitude()); + hash = (37 * hash) + LATITUDE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getLatitude()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.GeoCoordinate} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.GeoCoordinate) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinateOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + longitude_ = 0F; + latitude_ = 0F; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_GeoCoordinate_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.longitude_ = longitude_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.latitude_ = latitude_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate.getDefaultInstance()) return this; + if (other.getLongitude() != 0F) { + setLongitude(other.getLongitude()); + } + if (other.getLatitude() != 0F) { + setLatitude(other.getLatitude()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 13: { + longitude_ = input.readFloat(); + bitField0_ |= 0x00000001; + break; + } // case 13 + case 21: { + latitude_ = input.readFloat(); + bitField0_ |= 0x00000002; + break; + } // case 21 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private float longitude_ ; + /** + * float longitude = 1; + * @return The longitude. + */ + @java.lang.Override + public float getLongitude() { + return longitude_; + } + /** + * float longitude = 1; + * @param value The longitude to set. + * @return This builder for chaining. + */ + public Builder setLongitude(float value) { + + longitude_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * float longitude = 1; + * @return This builder for chaining. + */ + public Builder clearLongitude() { + bitField0_ = (bitField0_ & ~0x00000001); + longitude_ = 0F; + onChanged(); + return this; + } + + private float latitude_ ; + /** + * float latitude = 2; + * @return The latitude. + */ + @java.lang.Override + public float getLatitude() { + return latitude_; + } + /** + * float latitude = 2; + * @param value The latitude to set. + * @return This builder for chaining. + */ + public Builder setLatitude(float value) { + + latitude_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * float latitude = 2; + * @return This builder for chaining. + */ + public Builder clearLatitude() { + bitField0_ = (bitField0_ & ~0x00000002); + latitude_ = 0F; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.GeoCoordinate) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.GeoCoordinate) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GeoCoordinate parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.GeoCoordinate getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface PhoneNumberOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.PhoneNumber) + com.google.protobuf.MessageOrBuilder { + + /** + * uint64 country_code = 1; + * @return The countryCode. + */ + long getCountryCode(); + + /** + * string default_country = 2; + * @return The defaultCountry. + */ + java.lang.String getDefaultCountry(); + /** + * string default_country = 2; + * @return The bytes for defaultCountry. + */ + com.google.protobuf.ByteString + getDefaultCountryBytes(); + + /** + * string input = 3; + * @return The input. + */ + java.lang.String getInput(); + /** + * string input = 3; + * @return The bytes for input. + */ + com.google.protobuf.ByteString + getInputBytes(); + + /** + * string international_formatted = 4; + * @return The internationalFormatted. + */ + java.lang.String getInternationalFormatted(); + /** + * string international_formatted = 4; + * @return The bytes for internationalFormatted. + */ + com.google.protobuf.ByteString + getInternationalFormattedBytes(); + + /** + * uint64 national = 5; + * @return The national. + */ + long getNational(); + + /** + * string national_formatted = 6; + * @return The nationalFormatted. + */ + java.lang.String getNationalFormatted(); + /** + * string national_formatted = 6; + * @return The bytes for nationalFormatted. + */ + com.google.protobuf.ByteString + getNationalFormattedBytes(); + + /** + * bool valid = 7; + * @return The valid. + */ + boolean getValid(); + } + /** + * Protobuf type {@code weaviate.v1.PhoneNumber} + */ + public static final class PhoneNumber extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.PhoneNumber) + PhoneNumberOrBuilder { + private static final long serialVersionUID = 0L; + // Use PhoneNumber.newBuilder() to construct. + private PhoneNumber(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private PhoneNumber() { + defaultCountry_ = ""; + input_ = ""; + internationalFormatted_ = ""; + nationalFormatted_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new PhoneNumber(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder.class); + } + + public static final int COUNTRY_CODE_FIELD_NUMBER = 1; + private long countryCode_ = 0L; + /** + * uint64 country_code = 1; + * @return The countryCode. + */ + @java.lang.Override + public long getCountryCode() { + return countryCode_; + } + + public static final int DEFAULT_COUNTRY_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object defaultCountry_ = ""; + /** + * string default_country = 2; + * @return The defaultCountry. + */ + @java.lang.Override + public java.lang.String getDefaultCountry() { + java.lang.Object ref = defaultCountry_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + defaultCountry_ = s; + return s; + } + } + /** + * string default_country = 2; + * @return The bytes for defaultCountry. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getDefaultCountryBytes() { + java.lang.Object ref = defaultCountry_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + defaultCountry_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INPUT_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object input_ = ""; + /** + * string input = 3; + * @return The input. + */ + @java.lang.Override + public java.lang.String getInput() { + java.lang.Object ref = input_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + input_ = s; + return s; + } + } + /** + * string input = 3; + * @return The bytes for input. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getInputBytes() { + java.lang.Object ref = input_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + input_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INTERNATIONAL_FORMATTED_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private volatile java.lang.Object internationalFormatted_ = ""; + /** + * string international_formatted = 4; + * @return The internationalFormatted. + */ + @java.lang.Override + public java.lang.String getInternationalFormatted() { + java.lang.Object ref = internationalFormatted_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + internationalFormatted_ = s; + return s; + } + } + /** + * string international_formatted = 4; + * @return The bytes for internationalFormatted. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getInternationalFormattedBytes() { + java.lang.Object ref = internationalFormatted_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + internationalFormatted_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int NATIONAL_FIELD_NUMBER = 5; + private long national_ = 0L; + /** + * uint64 national = 5; + * @return The national. + */ + @java.lang.Override + public long getNational() { + return national_; + } + + public static final int NATIONAL_FORMATTED_FIELD_NUMBER = 6; + @SuppressWarnings("serial") + private volatile java.lang.Object nationalFormatted_ = ""; + /** + * string national_formatted = 6; + * @return The nationalFormatted. + */ + @java.lang.Override + public java.lang.String getNationalFormatted() { + java.lang.Object ref = nationalFormatted_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + nationalFormatted_ = s; + return s; + } + } + /** + * string national_formatted = 6; + * @return The bytes for nationalFormatted. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getNationalFormattedBytes() { + java.lang.Object ref = nationalFormatted_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + nationalFormatted_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VALID_FIELD_NUMBER = 7; + private boolean valid_ = false; + /** + * bool valid = 7; + * @return The valid. + */ + @java.lang.Override + public boolean getValid() { + return valid_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (countryCode_ != 0L) { + output.writeUInt64(1, countryCode_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(defaultCountry_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, defaultCountry_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(input_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, input_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(internationalFormatted_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, internationalFormatted_); + } + if (national_ != 0L) { + output.writeUInt64(5, national_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(nationalFormatted_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, nationalFormatted_); + } + if (valid_ != false) { + output.writeBool(7, valid_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (countryCode_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(1, countryCode_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(defaultCountry_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, defaultCountry_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(input_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, input_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(internationalFormatted_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, internationalFormatted_); + } + if (national_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(5, national_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(nationalFormatted_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, nationalFormatted_); + } + if (valid_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(7, valid_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) obj; + + if (getCountryCode() + != other.getCountryCode()) return false; + if (!getDefaultCountry() + .equals(other.getDefaultCountry())) return false; + if (!getInput() + .equals(other.getInput())) return false; + if (!getInternationalFormatted() + .equals(other.getInternationalFormatted())) return false; + if (getNational() + != other.getNational()) return false; + if (!getNationalFormatted() + .equals(other.getNationalFormatted())) return false; + if (getValid() + != other.getValid()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + COUNTRY_CODE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getCountryCode()); + hash = (37 * hash) + DEFAULT_COUNTRY_FIELD_NUMBER; + hash = (53 * hash) + getDefaultCountry().hashCode(); + hash = (37 * hash) + INPUT_FIELD_NUMBER; + hash = (53 * hash) + getInput().hashCode(); + hash = (37 * hash) + INTERNATIONAL_FORMATTED_FIELD_NUMBER; + hash = (53 * hash) + getInternationalFormatted().hashCode(); + hash = (37 * hash) + NATIONAL_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getNational()); + hash = (37 * hash) + NATIONAL_FORMATTED_FIELD_NUMBER; + hash = (53 * hash) + getNationalFormatted().hashCode(); + hash = (37 * hash) + VALID_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getValid()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.PhoneNumber} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.PhoneNumber) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumberOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + countryCode_ = 0L; + defaultCountry_ = ""; + input_ = ""; + internationalFormatted_ = ""; + national_ = 0L; + nationalFormatted_ = ""; + valid_ = false; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.internal_static_weaviate_v1_PhoneNumber_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.countryCode_ = countryCode_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.defaultCountry_ = defaultCountry_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.input_ = input_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.internationalFormatted_ = internationalFormatted_; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.national_ = national_; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.nationalFormatted_ = nationalFormatted_; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.valid_ = valid_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber.getDefaultInstance()) return this; + if (other.getCountryCode() != 0L) { + setCountryCode(other.getCountryCode()); + } + if (!other.getDefaultCountry().isEmpty()) { + defaultCountry_ = other.defaultCountry_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (!other.getInput().isEmpty()) { + input_ = other.input_; + bitField0_ |= 0x00000004; + onChanged(); + } + if (!other.getInternationalFormatted().isEmpty()) { + internationalFormatted_ = other.internationalFormatted_; + bitField0_ |= 0x00000008; + onChanged(); + } + if (other.getNational() != 0L) { + setNational(other.getNational()); + } + if (!other.getNationalFormatted().isEmpty()) { + nationalFormatted_ = other.nationalFormatted_; + bitField0_ |= 0x00000020; + onChanged(); + } + if (other.getValid() != false) { + setValid(other.getValid()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + countryCode_ = input.readUInt64(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 18: { + defaultCountry_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + input_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 34: { + internationalFormatted_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000008; + break; + } // case 34 + case 40: { + national_ = input.readUInt64(); + bitField0_ |= 0x00000010; + break; + } // case 40 + case 50: { + nationalFormatted_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000020; + break; + } // case 50 + case 56: { + valid_ = input.readBool(); + bitField0_ |= 0x00000040; + break; + } // case 56 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private long countryCode_ ; + /** + * uint64 country_code = 1; + * @return The countryCode. + */ + @java.lang.Override + public long getCountryCode() { + return countryCode_; + } + /** + * uint64 country_code = 1; + * @param value The countryCode to set. + * @return This builder for chaining. + */ + public Builder setCountryCode(long value) { + + countryCode_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * uint64 country_code = 1; + * @return This builder for chaining. + */ + public Builder clearCountryCode() { + bitField0_ = (bitField0_ & ~0x00000001); + countryCode_ = 0L; + onChanged(); + return this; + } + + private java.lang.Object defaultCountry_ = ""; + /** + * string default_country = 2; + * @return The defaultCountry. + */ + public java.lang.String getDefaultCountry() { + java.lang.Object ref = defaultCountry_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + defaultCountry_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string default_country = 2; + * @return The bytes for defaultCountry. + */ + public com.google.protobuf.ByteString + getDefaultCountryBytes() { + java.lang.Object ref = defaultCountry_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + defaultCountry_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string default_country = 2; + * @param value The defaultCountry to set. + * @return This builder for chaining. + */ + public Builder setDefaultCountry( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + defaultCountry_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string default_country = 2; + * @return This builder for chaining. + */ + public Builder clearDefaultCountry() { + defaultCountry_ = getDefaultInstance().getDefaultCountry(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string default_country = 2; + * @param value The bytes for defaultCountry to set. + * @return This builder for chaining. + */ + public Builder setDefaultCountryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + defaultCountry_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.lang.Object input_ = ""; + /** + * string input = 3; + * @return The input. + */ + public java.lang.String getInput() { + java.lang.Object ref = input_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + input_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string input = 3; + * @return The bytes for input. + */ + public com.google.protobuf.ByteString + getInputBytes() { + java.lang.Object ref = input_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + input_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string input = 3; + * @param value The input to set. + * @return This builder for chaining. + */ + public Builder setInput( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + input_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * string input = 3; + * @return This builder for chaining. + */ + public Builder clearInput() { + input_ = getDefaultInstance().getInput(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * string input = 3; + * @param value The bytes for input to set. + * @return This builder for chaining. + */ + public Builder setInputBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + input_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + + private java.lang.Object internationalFormatted_ = ""; + /** + * string international_formatted = 4; + * @return The internationalFormatted. + */ + public java.lang.String getInternationalFormatted() { + java.lang.Object ref = internationalFormatted_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + internationalFormatted_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string international_formatted = 4; + * @return The bytes for internationalFormatted. + */ + public com.google.protobuf.ByteString + getInternationalFormattedBytes() { + java.lang.Object ref = internationalFormatted_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + internationalFormatted_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string international_formatted = 4; + * @param value The internationalFormatted to set. + * @return This builder for chaining. + */ + public Builder setInternationalFormatted( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + internationalFormatted_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * string international_formatted = 4; + * @return This builder for chaining. + */ + public Builder clearInternationalFormatted() { + internationalFormatted_ = getDefaultInstance().getInternationalFormatted(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + /** + * string international_formatted = 4; + * @param value The bytes for internationalFormatted to set. + * @return This builder for chaining. + */ + public Builder setInternationalFormattedBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + internationalFormatted_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + + private long national_ ; + /** + * uint64 national = 5; + * @return The national. + */ + @java.lang.Override + public long getNational() { + return national_; + } + /** + * uint64 national = 5; + * @param value The national to set. + * @return This builder for chaining. + */ + public Builder setNational(long value) { + + national_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * uint64 national = 5; + * @return This builder for chaining. + */ + public Builder clearNational() { + bitField0_ = (bitField0_ & ~0x00000010); + national_ = 0L; + onChanged(); + return this; + } + + private java.lang.Object nationalFormatted_ = ""; + /** + * string national_formatted = 6; + * @return The nationalFormatted. + */ + public java.lang.String getNationalFormatted() { + java.lang.Object ref = nationalFormatted_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + nationalFormatted_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string national_formatted = 6; + * @return The bytes for nationalFormatted. + */ + public com.google.protobuf.ByteString + getNationalFormattedBytes() { + java.lang.Object ref = nationalFormatted_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + nationalFormatted_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string national_formatted = 6; + * @param value The nationalFormatted to set. + * @return This builder for chaining. + */ + public Builder setNationalFormatted( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + nationalFormatted_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * string national_formatted = 6; + * @return This builder for chaining. + */ + public Builder clearNationalFormatted() { + nationalFormatted_ = getDefaultInstance().getNationalFormatted(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + /** + * string national_formatted = 6; + * @param value The bytes for nationalFormatted to set. + * @return This builder for chaining. + */ + public Builder setNationalFormattedBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + nationalFormatted_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + + private boolean valid_ ; + /** + * bool valid = 7; + * @return The valid. + */ + @java.lang.Override + public boolean getValid() { + return valid_; + } + /** + * bool valid = 7; + * @param value The valid to set. + * @return This builder for chaining. + */ + public Builder setValid(boolean value) { + + valid_ = value; + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + * bool valid = 7; + * @return This builder for chaining. + */ + public Builder clearValid() { + bitField0_ = (bitField0_ & ~0x00000040); + valid_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.PhoneNumber) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.PhoneNumber) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public PhoneNumber parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PhoneNumber getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_Properties_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_Properties_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_Properties_FieldsEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_Properties_FieldsEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_Value_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_Value_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ListValue_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ListValue_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_NumberValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_NumberValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_TextValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_TextValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_BoolValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_BoolValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ObjectValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ObjectValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_DateValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_DateValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_UuidValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_UuidValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_IntValues_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_IntValues_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_GeoCoordinate_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_PhoneNumber_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\023v1/properties.proto\022\013weaviate.v1\032\034goog" + + "le/protobuf/struct.proto\"\204\001\n\nProperties\022" + + "3\n\006fields\030\001 \003(\0132#.weaviate.v1.Properties" + + ".FieldsEntry\032A\n\013FieldsEntry\022\013\n\003key\030\001 \001(\t" + + "\022!\n\005value\030\002 \001(\0132\022.weaviate.v1.Value:\0028\001\"" + + "\235\003\n\005Value\022\026\n\014number_value\030\001 \001(\001H\000\022\024\n\nboo" + + "l_value\030\003 \001(\010H\000\022/\n\014object_value\030\004 \001(\0132\027." + + "weaviate.v1.PropertiesH\000\022,\n\nlist_value\030\005" + + " \001(\0132\026.weaviate.v1.ListValueH\000\022\024\n\ndate_v" + + "alue\030\006 \001(\tH\000\022\024\n\nuuid_value\030\007 \001(\tH\000\022\023\n\tin" + + "t_value\030\010 \001(\003H\000\022/\n\tgeo_value\030\t \001(\0132\032.wea" + + "viate.v1.GeoCoordinateH\000\022\024\n\nblob_value\030\n" + + " \001(\tH\000\022/\n\013phone_value\030\013 \001(\0132\030.weaviate.v" + + "1.PhoneNumberH\000\0220\n\nnull_value\030\014 \001(\0162\032.go" + + "ogle.protobuf.NullValueH\000\022\024\n\ntext_value\030" + + "\r \001(\tH\000B\006\n\004kind\"\357\002\n\tListValue\0222\n\rnumber_" + + "values\030\002 \001(\0132\031.weaviate.v1.NumberValuesH" + + "\000\022.\n\013bool_values\030\003 \001(\0132\027.weaviate.v1.Boo" + + "lValuesH\000\0222\n\robject_values\030\004 \001(\0132\031.weavi" + + "ate.v1.ObjectValuesH\000\022.\n\013date_values\030\005 \001" + + "(\0132\027.weaviate.v1.DateValuesH\000\022.\n\013uuid_va" + + "lues\030\006 \001(\0132\027.weaviate.v1.UuidValuesH\000\022,\n" + + "\nint_values\030\007 \001(\0132\026.weaviate.v1.IntValue" + + "sH\000\022.\n\013text_values\030\010 \001(\0132\027.weaviate.v1.T" + + "extValuesH\000B\006\n\004kindJ\004\010\001\020\002\"\036\n\014NumberValue" + + "s\022\016\n\006values\030\001 \001(\014\"\034\n\nTextValues\022\016\n\006value" + + "s\030\001 \003(\t\"\034\n\nBoolValues\022\016\n\006values\030\001 \003(\010\"7\n" + + "\014ObjectValues\022\'\n\006values\030\001 \003(\0132\027.weaviate" + + ".v1.Properties\"\034\n\nDateValues\022\016\n\006values\030\001" + + " \003(\t\"\034\n\nUuidValues\022\016\n\006values\030\001 \003(\t\"\033\n\tIn" + + "tValues\022\016\n\006values\030\001 \001(\014\"4\n\rGeoCoordinate" + + "\022\021\n\tlongitude\030\001 \001(\002\022\020\n\010latitude\030\002 \001(\002\"\251\001" + + "\n\013PhoneNumber\022\024\n\014country_code\030\001 \001(\004\022\027\n\017d" + + "efault_country\030\002 \001(\t\022\r\n\005input\030\003 \001(\t\022\037\n\027i" + + "nternational_formatted\030\004 \001(\t\022\020\n\010national" + + "\030\005 \001(\004\022\032\n\022national_formatted\030\006 \001(\t\022\r\n\005va" + + "lid\030\007 \001(\010BH\n-io.weaviate.client6.v1.inte" + + "rnal.grpc.protocolB\027WeaviateProtoPropert" + + "iesb\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.google.protobuf.StructProto.getDescriptor(), + }); + internal_static_weaviate_v1_Properties_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_weaviate_v1_Properties_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_Properties_descriptor, + new java.lang.String[] { "Fields", }); + internal_static_weaviate_v1_Properties_FieldsEntry_descriptor = + internal_static_weaviate_v1_Properties_descriptor.getNestedTypes().get(0); + internal_static_weaviate_v1_Properties_FieldsEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_Properties_FieldsEntry_descriptor, + new java.lang.String[] { "Key", "Value", }); + internal_static_weaviate_v1_Value_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_weaviate_v1_Value_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_Value_descriptor, + new java.lang.String[] { "NumberValue", "BoolValue", "ObjectValue", "ListValue", "DateValue", "UuidValue", "IntValue", "GeoValue", "BlobValue", "PhoneValue", "NullValue", "TextValue", "Kind", }); + internal_static_weaviate_v1_ListValue_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_weaviate_v1_ListValue_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ListValue_descriptor, + new java.lang.String[] { "NumberValues", "BoolValues", "ObjectValues", "DateValues", "UuidValues", "IntValues", "TextValues", "Kind", }); + internal_static_weaviate_v1_NumberValues_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_weaviate_v1_NumberValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_NumberValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_TextValues_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_weaviate_v1_TextValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_TextValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_BoolValues_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_weaviate_v1_BoolValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_BoolValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_ObjectValues_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_weaviate_v1_ObjectValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ObjectValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_DateValues_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_weaviate_v1_DateValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_DateValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_UuidValues_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_weaviate_v1_UuidValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_UuidValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_IntValues_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_weaviate_v1_IntValues_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_IntValues_descriptor, + new java.lang.String[] { "Values", }); + internal_static_weaviate_v1_GeoCoordinate_descriptor = + getDescriptor().getMessageTypes().get(10); + internal_static_weaviate_v1_GeoCoordinate_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_GeoCoordinate_descriptor, + new java.lang.String[] { "Longitude", "Latitude", }); + internal_static_weaviate_v1_PhoneNumber_descriptor = + getDescriptor().getMessageTypes().get(11); + internal_static_weaviate_v1_PhoneNumber_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_PhoneNumber_descriptor, + new java.lang.String[] { "CountryCode", "DefaultCountry", "Input", "InternationalFormatted", "National", "NationalFormatted", "Valid", }); + com.google.protobuf.StructProto.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoSearchGet.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoSearchGet.java new file mode 100644 index 000000000..326ede844 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoSearchGet.java @@ -0,0 +1,23354 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: v1/search_get.proto + +package io.weaviate.client6.v1.internal.grpc.protocol; + +public final class WeaviateProtoSearchGet { + private WeaviateProtoSearchGet() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface SearchRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchRequest) + com.google.protobuf.MessageOrBuilder { + + /** + *
+     *required
+     * 
+ * + * string collection = 1; + * @return The collection. + */ + java.lang.String getCollection(); + /** + *
+     *required
+     * 
+ * + * string collection = 1; + * @return The bytes for collection. + */ + com.google.protobuf.ByteString + getCollectionBytes(); + + /** + *
+     * parameters
+     * 
+ * + * string tenant = 10; + * @return The tenant. + */ + java.lang.String getTenant(); + /** + *
+     * parameters
+     * 
+ * + * string tenant = 10; + * @return The bytes for tenant. + */ + com.google.protobuf.ByteString + getTenantBytes(); + + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return Whether the consistencyLevel field is set. + */ + boolean hasConsistencyLevel(); + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The enum numeric value on the wire for consistencyLevel. + */ + int getConsistencyLevelValue(); + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The consistencyLevel. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel(); + + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return Whether the properties field is set. + */ + boolean hasProperties(); + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return The properties. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties(); + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder(); + + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return Whether the metadata field is set. + */ + boolean hasMetadata(); + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return The metadata. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata(); + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder(); + + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return Whether the groupBy field is set. + */ + boolean hasGroupBy(); + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return The groupBy. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getGroupBy(); + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder(); + + /** + *
+     * affects order and length of results. 0/empty (default value) means disabled
+     * 
+ * + * uint32 limit = 30; + * @return The limit. + */ + int getLimit(); + + /** + * uint32 offset = 31; + * @return The offset. + */ + int getOffset(); + + /** + * uint32 autocut = 32; + * @return The autocut. + */ + int getAutocut(); + + /** + * string after = 33; + * @return The after. + */ + java.lang.String getAfter(); + /** + * string after = 33; + * @return The bytes for after. + */ + com.google.protobuf.ByteString + getAfterBytes(); + + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + java.util.List + getSortByList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getSortBy(int index); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + int getSortByCount(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + java.util.List + getSortByOrBuilderList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( + int index); + + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return Whether the filters field is set. + */ + boolean hasFilters(); + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return The filters. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters(); + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder(); + + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return Whether the hybridSearch field is set. + */ + boolean hasHybridSearch(); + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return The hybridSearch. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybridSearch(); + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder(); + + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return Whether the bm25Search field is set. + */ + boolean hasBm25Search(); + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return The bm25Search. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getBm25Search(); + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder(); + + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return Whether the nearVector field is set. + */ + boolean hasNearVector(); + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return The nearVector. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector(); + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder(); + + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return Whether the nearObject field is set. + */ + boolean hasNearObject(); + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return The nearObject. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject(); + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder(); + + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return Whether the nearText field is set. + */ + boolean hasNearText(); + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return The nearText. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText(); + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder(); + + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return Whether the nearImage field is set. + */ + boolean hasNearImage(); + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return The nearImage. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage(); + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder(); + + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return Whether the nearAudio field is set. + */ + boolean hasNearAudio(); + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return The nearAudio. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio(); + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder(); + + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return Whether the nearVideo field is set. + */ + boolean hasNearVideo(); + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return The nearVideo. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo(); + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder(); + + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return Whether the nearDepth field is set. + */ + boolean hasNearDepth(); + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return The nearDepth. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth(); + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder(); + + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return Whether the nearThermal field is set. + */ + boolean hasNearThermal(); + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return The nearThermal. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal(); + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder(); + + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return Whether the nearImu field is set. + */ + boolean hasNearImu(); + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return The nearImu. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu(); + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder(); + + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return Whether the generative field is set. + */ + boolean hasGenerative(); + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return The generative. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getGenerative(); + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder(); + + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return Whether the rerank field is set. + */ + boolean hasRerank(); + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return The rerank. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getRerank(); + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder(); + + /** + * bool uses_123_api = 100 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. + * See v1/search_get.proto;l=50 + * @return The uses123Api. + */ + @java.lang.Deprecated boolean getUses123Api(); + + /** + * bool uses_125_api = 101 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. + * See v1/search_get.proto;l=51 + * @return The uses125Api. + */ + @java.lang.Deprecated boolean getUses125Api(); + + /** + * bool uses_127_api = 102; + * @return The uses127Api. + */ + boolean getUses127Api(); + } + /** + * Protobuf type {@code weaviate.v1.SearchRequest} + */ + public static final class SearchRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.SearchRequest) + SearchRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use SearchRequest.newBuilder() to construct. + private SearchRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SearchRequest() { + collection_ = ""; + tenant_ = ""; + consistencyLevel_ = 0; + after_ = ""; + sortBy_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SearchRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object collection_ = ""; + /** + *
+     *required
+     * 
+ * + * string collection = 1; + * @return The collection. + */ + @java.lang.Override + public java.lang.String getCollection() { + java.lang.Object ref = collection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + collection_ = s; + return s; + } + } + /** + *
+     *required
+     * 
+ * + * string collection = 1; + * @return The bytes for collection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getCollectionBytes() { + java.lang.Object ref = collection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + collection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TENANT_FIELD_NUMBER = 10; + @SuppressWarnings("serial") + private volatile java.lang.Object tenant_ = ""; + /** + *
+     * parameters
+     * 
+ * + * string tenant = 10; + * @return The tenant. + */ + @java.lang.Override + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } + } + /** + *
+     * parameters
+     * 
+ * + * string tenant = 10; + * @return The bytes for tenant. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int CONSISTENCY_LEVEL_FIELD_NUMBER = 11; + private int consistencyLevel_ = 0; + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return Whether the consistencyLevel field is set. + */ + @java.lang.Override public boolean hasConsistencyLevel() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The enum numeric value on the wire for consistencyLevel. + */ + @java.lang.Override public int getConsistencyLevelValue() { + return consistencyLevel_; + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The consistencyLevel. + */ + @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; + } + + public static final int PROPERTIES_FIELD_NUMBER = 20; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest properties_; + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return Whether the properties field is set. + */ + @java.lang.Override + public boolean hasProperties() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return The properties. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + /** + *
+     * what is returned
+     * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + + public static final int METADATA_FIELD_NUMBER = 21; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest metadata_; + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return Whether the metadata field is set. + */ + @java.lang.Override + public boolean hasMetadata() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return The metadata. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + + public static final int GROUP_BY_FIELD_NUMBER = 22; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy groupBy_; + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return Whether the groupBy field is set. + */ + @java.lang.Override + public boolean hasGroupBy() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return The groupBy. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getGroupBy() { + return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder() { + return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; + } + + public static final int LIMIT_FIELD_NUMBER = 30; + private int limit_ = 0; + /** + *
+     * affects order and length of results. 0/empty (default value) means disabled
+     * 
+ * + * uint32 limit = 30; + * @return The limit. + */ + @java.lang.Override + public int getLimit() { + return limit_; + } + + public static final int OFFSET_FIELD_NUMBER = 31; + private int offset_ = 0; + /** + * uint32 offset = 31; + * @return The offset. + */ + @java.lang.Override + public int getOffset() { + return offset_; + } + + public static final int AUTOCUT_FIELD_NUMBER = 32; + private int autocut_ = 0; + /** + * uint32 autocut = 32; + * @return The autocut. + */ + @java.lang.Override + public int getAutocut() { + return autocut_; + } + + public static final int AFTER_FIELD_NUMBER = 33; + @SuppressWarnings("serial") + private volatile java.lang.Object after_ = ""; + /** + * string after = 33; + * @return The after. + */ + @java.lang.Override + public java.lang.String getAfter() { + java.lang.Object ref = after_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + after_ = s; + return s; + } + } + /** + * string after = 33; + * @return The bytes for after. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getAfterBytes() { + java.lang.Object ref = after_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + after_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SORT_BY_FIELD_NUMBER = 34; + @SuppressWarnings("serial") + private java.util.List sortBy_; + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + @java.lang.Override + public java.util.List getSortByList() { + return sortBy_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + @java.lang.Override + public java.util.List + getSortByOrBuilderList() { + return sortBy_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + @java.lang.Override + public int getSortByCount() { + return sortBy_.size(); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getSortBy(int index) { + return sortBy_.get(index); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( + int index) { + return sortBy_.get(index); + } + + public static final int FILTERS_FIELD_NUMBER = 40; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_; + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return Whether the filters field is set. + */ + @java.lang.Override + public boolean hasFilters() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return The filters. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() { + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + } + /** + *
+     * matches/searches for objects
+     * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + } + + public static final int HYBRID_SEARCH_FIELD_NUMBER = 41; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid hybridSearch_; + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return Whether the hybridSearch field is set. + */ + @java.lang.Override + public boolean hasHybridSearch() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return The hybridSearch. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybridSearch() { + return hybridSearch_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder() { + return hybridSearch_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; + } + + public static final int BM25_SEARCH_FIELD_NUMBER = 42; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 bm25Search_; + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return Whether the bm25Search field is set. + */ + @java.lang.Override + public boolean hasBm25Search() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return The bm25Search. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getBm25Search() { + return bm25Search_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder() { + return bm25Search_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; + } + + public static final int NEAR_VECTOR_FIELD_NUMBER = 43; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector nearVector_; + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return Whether the nearVector field is set. + */ + @java.lang.Override + public boolean hasNearVector() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return The nearVector. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() { + return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() { + return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; + } + + public static final int NEAR_OBJECT_FIELD_NUMBER = 44; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject nearObject_; + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return Whether the nearObject field is set. + */ + @java.lang.Override + public boolean hasNearObject() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return The nearObject. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject() { + return nearObject_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() { + return nearObject_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; + } + + public static final int NEAR_TEXT_FIELD_NUMBER = 45; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch nearText_; + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return Whether the nearText field is set. + */ + @java.lang.Override + public boolean hasNearText() { + return ((bitField0_ & 0x00000200) != 0); + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return The nearText. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() { + return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() { + return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; + } + + public static final int NEAR_IMAGE_FIELD_NUMBER = 46; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch nearImage_; + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return Whether the nearImage field is set. + */ + @java.lang.Override + public boolean hasNearImage() { + return ((bitField0_ & 0x00000400) != 0); + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return The nearImage. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage() { + return nearImage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() { + return nearImage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; + } + + public static final int NEAR_AUDIO_FIELD_NUMBER = 47; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch nearAudio_; + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return Whether the nearAudio field is set. + */ + @java.lang.Override + public boolean hasNearAudio() { + return ((bitField0_ & 0x00000800) != 0); + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return The nearAudio. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() { + return nearAudio_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() { + return nearAudio_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; + } + + public static final int NEAR_VIDEO_FIELD_NUMBER = 48; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch nearVideo_; + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return Whether the nearVideo field is set. + */ + @java.lang.Override + public boolean hasNearVideo() { + return ((bitField0_ & 0x00001000) != 0); + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return The nearVideo. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() { + return nearVideo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() { + return nearVideo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; + } + + public static final int NEAR_DEPTH_FIELD_NUMBER = 49; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch nearDepth_; + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return Whether the nearDepth field is set. + */ + @java.lang.Override + public boolean hasNearDepth() { + return ((bitField0_ & 0x00002000) != 0); + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return The nearDepth. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() { + return nearDepth_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() { + return nearDepth_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; + } + + public static final int NEAR_THERMAL_FIELD_NUMBER = 50; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch nearThermal_; + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return Whether the nearThermal field is set. + */ + @java.lang.Override + public boolean hasNearThermal() { + return ((bitField0_ & 0x00004000) != 0); + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return The nearThermal. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() { + return nearThermal_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() { + return nearThermal_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; + } + + public static final int NEAR_IMU_FIELD_NUMBER = 51; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch nearImu_; + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return Whether the nearImu field is set. + */ + @java.lang.Override + public boolean hasNearImu() { + return ((bitField0_ & 0x00008000) != 0); + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return The nearImu. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() { + return nearImu_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() { + return nearImu_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; + } + + public static final int GENERATIVE_FIELD_NUMBER = 60; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch generative_; + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return Whether the generative field is set. + */ + @java.lang.Override + public boolean hasGenerative() { + return ((bitField0_ & 0x00010000) != 0); + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return The generative. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getGenerative() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; + } + + public static final int RERANK_FIELD_NUMBER = 61; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank rerank_; + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return Whether the rerank field is set. + */ + @java.lang.Override + public boolean hasRerank() { + return ((bitField0_ & 0x00020000) != 0); + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return The rerank. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getRerank() { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder() { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; + } + + public static final int USES_123_API_FIELD_NUMBER = 100; + private boolean uses123Api_ = false; + /** + * bool uses_123_api = 100 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. + * See v1/search_get.proto;l=50 + * @return The uses123Api. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getUses123Api() { + return uses123Api_; + } + + public static final int USES_125_API_FIELD_NUMBER = 101; + private boolean uses125Api_ = false; + /** + * bool uses_125_api = 101 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. + * See v1/search_get.proto;l=51 + * @return The uses125Api. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getUses125Api() { + return uses125Api_; + } + + public static final int USES_127_API_FIELD_NUMBER = 102; + private boolean uses127Api_ = false; + /** + * bool uses_127_api = 102; + * @return The uses127Api. + */ + @java.lang.Override + public boolean getUses127Api() { + return uses127Api_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, collection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 10, tenant_); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(11, consistencyLevel_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(20, getProperties()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(21, getMetadata()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(22, getGroupBy()); + } + if (limit_ != 0) { + output.writeUInt32(30, limit_); + } + if (offset_ != 0) { + output.writeUInt32(31, offset_); + } + if (autocut_ != 0) { + output.writeUInt32(32, autocut_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(after_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 33, after_); + } + for (int i = 0; i < sortBy_.size(); i++) { + output.writeMessage(34, sortBy_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(40, getFilters()); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeMessage(41, getHybridSearch()); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeMessage(42, getBm25Search()); + } + if (((bitField0_ & 0x00000080) != 0)) { + output.writeMessage(43, getNearVector()); + } + if (((bitField0_ & 0x00000100) != 0)) { + output.writeMessage(44, getNearObject()); + } + if (((bitField0_ & 0x00000200) != 0)) { + output.writeMessage(45, getNearText()); + } + if (((bitField0_ & 0x00000400) != 0)) { + output.writeMessage(46, getNearImage()); + } + if (((bitField0_ & 0x00000800) != 0)) { + output.writeMessage(47, getNearAudio()); + } + if (((bitField0_ & 0x00001000) != 0)) { + output.writeMessage(48, getNearVideo()); + } + if (((bitField0_ & 0x00002000) != 0)) { + output.writeMessage(49, getNearDepth()); + } + if (((bitField0_ & 0x00004000) != 0)) { + output.writeMessage(50, getNearThermal()); + } + if (((bitField0_ & 0x00008000) != 0)) { + output.writeMessage(51, getNearImu()); + } + if (((bitField0_ & 0x00010000) != 0)) { + output.writeMessage(60, getGenerative()); + } + if (((bitField0_ & 0x00020000) != 0)) { + output.writeMessage(61, getRerank()); + } + if (uses123Api_ != false) { + output.writeBool(100, uses123Api_); + } + if (uses125Api_ != false) { + output.writeBool(101, uses125Api_); + } + if (uses127Api_ != false) { + output.writeBool(102, uses127Api_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(collection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, collection_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(tenant_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(10, tenant_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(11, consistencyLevel_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(20, getProperties()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(21, getMetadata()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(22, getGroupBy()); + } + if (limit_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(30, limit_); + } + if (offset_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(31, offset_); + } + if (autocut_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(32, autocut_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(after_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(33, after_); + } + for (int i = 0; i < sortBy_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(34, sortBy_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(40, getFilters()); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(41, getHybridSearch()); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(42, getBm25Search()); + } + if (((bitField0_ & 0x00000080) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(43, getNearVector()); + } + if (((bitField0_ & 0x00000100) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(44, getNearObject()); + } + if (((bitField0_ & 0x00000200) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(45, getNearText()); + } + if (((bitField0_ & 0x00000400) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(46, getNearImage()); + } + if (((bitField0_ & 0x00000800) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(47, getNearAudio()); + } + if (((bitField0_ & 0x00001000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(48, getNearVideo()); + } + if (((bitField0_ & 0x00002000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(49, getNearDepth()); + } + if (((bitField0_ & 0x00004000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(50, getNearThermal()); + } + if (((bitField0_ & 0x00008000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(51, getNearImu()); + } + if (((bitField0_ & 0x00010000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(60, getGenerative()); + } + if (((bitField0_ & 0x00020000) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(61, getRerank()); + } + if (uses123Api_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(100, uses123Api_); + } + if (uses125Api_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(101, uses125Api_); + } + if (uses127Api_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(102, uses127Api_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest) obj; + + if (!getCollection() + .equals(other.getCollection())) return false; + if (!getTenant() + .equals(other.getTenant())) return false; + if (hasConsistencyLevel() != other.hasConsistencyLevel()) return false; + if (hasConsistencyLevel()) { + if (consistencyLevel_ != other.consistencyLevel_) return false; + } + if (hasProperties() != other.hasProperties()) return false; + if (hasProperties()) { + if (!getProperties() + .equals(other.getProperties())) return false; + } + if (hasMetadata() != other.hasMetadata()) return false; + if (hasMetadata()) { + if (!getMetadata() + .equals(other.getMetadata())) return false; + } + if (hasGroupBy() != other.hasGroupBy()) return false; + if (hasGroupBy()) { + if (!getGroupBy() + .equals(other.getGroupBy())) return false; + } + if (getLimit() + != other.getLimit()) return false; + if (getOffset() + != other.getOffset()) return false; + if (getAutocut() + != other.getAutocut()) return false; + if (!getAfter() + .equals(other.getAfter())) return false; + if (!getSortByList() + .equals(other.getSortByList())) return false; + if (hasFilters() != other.hasFilters()) return false; + if (hasFilters()) { + if (!getFilters() + .equals(other.getFilters())) return false; + } + if (hasHybridSearch() != other.hasHybridSearch()) return false; + if (hasHybridSearch()) { + if (!getHybridSearch() + .equals(other.getHybridSearch())) return false; + } + if (hasBm25Search() != other.hasBm25Search()) return false; + if (hasBm25Search()) { + if (!getBm25Search() + .equals(other.getBm25Search())) return false; + } + if (hasNearVector() != other.hasNearVector()) return false; + if (hasNearVector()) { + if (!getNearVector() + .equals(other.getNearVector())) return false; + } + if (hasNearObject() != other.hasNearObject()) return false; + if (hasNearObject()) { + if (!getNearObject() + .equals(other.getNearObject())) return false; + } + if (hasNearText() != other.hasNearText()) return false; + if (hasNearText()) { + if (!getNearText() + .equals(other.getNearText())) return false; + } + if (hasNearImage() != other.hasNearImage()) return false; + if (hasNearImage()) { + if (!getNearImage() + .equals(other.getNearImage())) return false; + } + if (hasNearAudio() != other.hasNearAudio()) return false; + if (hasNearAudio()) { + if (!getNearAudio() + .equals(other.getNearAudio())) return false; + } + if (hasNearVideo() != other.hasNearVideo()) return false; + if (hasNearVideo()) { + if (!getNearVideo() + .equals(other.getNearVideo())) return false; + } + if (hasNearDepth() != other.hasNearDepth()) return false; + if (hasNearDepth()) { + if (!getNearDepth() + .equals(other.getNearDepth())) return false; + } + if (hasNearThermal() != other.hasNearThermal()) return false; + if (hasNearThermal()) { + if (!getNearThermal() + .equals(other.getNearThermal())) return false; + } + if (hasNearImu() != other.hasNearImu()) return false; + if (hasNearImu()) { + if (!getNearImu() + .equals(other.getNearImu())) return false; + } + if (hasGenerative() != other.hasGenerative()) return false; + if (hasGenerative()) { + if (!getGenerative() + .equals(other.getGenerative())) return false; + } + if (hasRerank() != other.hasRerank()) return false; + if (hasRerank()) { + if (!getRerank() + .equals(other.getRerank())) return false; + } + if (getUses123Api() + != other.getUses123Api()) return false; + if (getUses125Api() + != other.getUses125Api()) return false; + if (getUses127Api() + != other.getUses127Api()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + hash = (37 * hash) + TENANT_FIELD_NUMBER; + hash = (53 * hash) + getTenant().hashCode(); + if (hasConsistencyLevel()) { + hash = (37 * hash) + CONSISTENCY_LEVEL_FIELD_NUMBER; + hash = (53 * hash) + consistencyLevel_; + } + if (hasProperties()) { + hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getProperties().hashCode(); + } + if (hasMetadata()) { + hash = (37 * hash) + METADATA_FIELD_NUMBER; + hash = (53 * hash) + getMetadata().hashCode(); + } + if (hasGroupBy()) { + hash = (37 * hash) + GROUP_BY_FIELD_NUMBER; + hash = (53 * hash) + getGroupBy().hashCode(); + } + hash = (37 * hash) + LIMIT_FIELD_NUMBER; + hash = (53 * hash) + getLimit(); + hash = (37 * hash) + OFFSET_FIELD_NUMBER; + hash = (53 * hash) + getOffset(); + hash = (37 * hash) + AUTOCUT_FIELD_NUMBER; + hash = (53 * hash) + getAutocut(); + hash = (37 * hash) + AFTER_FIELD_NUMBER; + hash = (53 * hash) + getAfter().hashCode(); + if (getSortByCount() > 0) { + hash = (37 * hash) + SORT_BY_FIELD_NUMBER; + hash = (53 * hash) + getSortByList().hashCode(); + } + if (hasFilters()) { + hash = (37 * hash) + FILTERS_FIELD_NUMBER; + hash = (53 * hash) + getFilters().hashCode(); + } + if (hasHybridSearch()) { + hash = (37 * hash) + HYBRID_SEARCH_FIELD_NUMBER; + hash = (53 * hash) + getHybridSearch().hashCode(); + } + if (hasBm25Search()) { + hash = (37 * hash) + BM25_SEARCH_FIELD_NUMBER; + hash = (53 * hash) + getBm25Search().hashCode(); + } + if (hasNearVector()) { + hash = (37 * hash) + NEAR_VECTOR_FIELD_NUMBER; + hash = (53 * hash) + getNearVector().hashCode(); + } + if (hasNearObject()) { + hash = (37 * hash) + NEAR_OBJECT_FIELD_NUMBER; + hash = (53 * hash) + getNearObject().hashCode(); + } + if (hasNearText()) { + hash = (37 * hash) + NEAR_TEXT_FIELD_NUMBER; + hash = (53 * hash) + getNearText().hashCode(); + } + if (hasNearImage()) { + hash = (37 * hash) + NEAR_IMAGE_FIELD_NUMBER; + hash = (53 * hash) + getNearImage().hashCode(); + } + if (hasNearAudio()) { + hash = (37 * hash) + NEAR_AUDIO_FIELD_NUMBER; + hash = (53 * hash) + getNearAudio().hashCode(); + } + if (hasNearVideo()) { + hash = (37 * hash) + NEAR_VIDEO_FIELD_NUMBER; + hash = (53 * hash) + getNearVideo().hashCode(); + } + if (hasNearDepth()) { + hash = (37 * hash) + NEAR_DEPTH_FIELD_NUMBER; + hash = (53 * hash) + getNearDepth().hashCode(); + } + if (hasNearThermal()) { + hash = (37 * hash) + NEAR_THERMAL_FIELD_NUMBER; + hash = (53 * hash) + getNearThermal().hashCode(); + } + if (hasNearImu()) { + hash = (37 * hash) + NEAR_IMU_FIELD_NUMBER; + hash = (53 * hash) + getNearImu().hashCode(); + } + if (hasGenerative()) { + hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; + hash = (53 * hash) + getGenerative().hashCode(); + } + if (hasRerank()) { + hash = (37 * hash) + RERANK_FIELD_NUMBER; + hash = (53 * hash) + getRerank().hashCode(); + } + hash = (37 * hash) + USES_123_API_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getUses123Api()); + hash = (37 * hash) + USES_125_API_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getUses125Api()); + hash = (37 * hash) + USES_127_API_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getUses127Api()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.SearchRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPropertiesFieldBuilder(); + getMetadataFieldBuilder(); + getGroupByFieldBuilder(); + getSortByFieldBuilder(); + getFiltersFieldBuilder(); + getHybridSearchFieldBuilder(); + getBm25SearchFieldBuilder(); + getNearVectorFieldBuilder(); + getNearObjectFieldBuilder(); + getNearTextFieldBuilder(); + getNearImageFieldBuilder(); + getNearAudioFieldBuilder(); + getNearVideoFieldBuilder(); + getNearDepthFieldBuilder(); + getNearThermalFieldBuilder(); + getNearImuFieldBuilder(); + getGenerativeFieldBuilder(); + getRerankFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + collection_ = ""; + tenant_ = ""; + consistencyLevel_ = 0; + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + groupBy_ = null; + if (groupByBuilder_ != null) { + groupByBuilder_.dispose(); + groupByBuilder_ = null; + } + limit_ = 0; + offset_ = 0; + autocut_ = 0; + after_ = ""; + if (sortByBuilder_ == null) { + sortBy_ = java.util.Collections.emptyList(); + } else { + sortBy_ = null; + sortByBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000400); + filters_ = null; + if (filtersBuilder_ != null) { + filtersBuilder_.dispose(); + filtersBuilder_ = null; + } + hybridSearch_ = null; + if (hybridSearchBuilder_ != null) { + hybridSearchBuilder_.dispose(); + hybridSearchBuilder_ = null; + } + bm25Search_ = null; + if (bm25SearchBuilder_ != null) { + bm25SearchBuilder_.dispose(); + bm25SearchBuilder_ = null; + } + nearVector_ = null; + if (nearVectorBuilder_ != null) { + nearVectorBuilder_.dispose(); + nearVectorBuilder_ = null; + } + nearObject_ = null; + if (nearObjectBuilder_ != null) { + nearObjectBuilder_.dispose(); + nearObjectBuilder_ = null; + } + nearText_ = null; + if (nearTextBuilder_ != null) { + nearTextBuilder_.dispose(); + nearTextBuilder_ = null; + } + nearImage_ = null; + if (nearImageBuilder_ != null) { + nearImageBuilder_.dispose(); + nearImageBuilder_ = null; + } + nearAudio_ = null; + if (nearAudioBuilder_ != null) { + nearAudioBuilder_.dispose(); + nearAudioBuilder_ = null; + } + nearVideo_ = null; + if (nearVideoBuilder_ != null) { + nearVideoBuilder_.dispose(); + nearVideoBuilder_ = null; + } + nearDepth_ = null; + if (nearDepthBuilder_ != null) { + nearDepthBuilder_.dispose(); + nearDepthBuilder_ = null; + } + nearThermal_ = null; + if (nearThermalBuilder_ != null) { + nearThermalBuilder_.dispose(); + nearThermalBuilder_ = null; + } + nearImu_ = null; + if (nearImuBuilder_ != null) { + nearImuBuilder_.dispose(); + nearImuBuilder_ = null; + } + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + rerank_ = null; + if (rerankBuilder_ != null) { + rerankBuilder_.dispose(); + rerankBuilder_ = null; + } + uses123Api_ = false; + uses125Api_ = false; + uses127Api_ = false; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest result) { + if (sortByBuilder_ == null) { + if (((bitField0_ & 0x00000400) != 0)) { + sortBy_ = java.util.Collections.unmodifiableList(sortBy_); + bitField0_ = (bitField0_ & ~0x00000400); + } + result.sortBy_ = sortBy_; + } else { + result.sortBy_ = sortByBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.collection_ = collection_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.tenant_ = tenant_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000004) != 0)) { + result.consistencyLevel_ = consistencyLevel_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.properties_ = propertiesBuilder_ == null + ? properties_ + : propertiesBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.metadata_ = metadataBuilder_ == null + ? metadata_ + : metadataBuilder_.build(); + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.groupBy_ = groupByBuilder_ == null + ? groupBy_ + : groupByBuilder_.build(); + to_bitField0_ |= 0x00000008; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.limit_ = limit_; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + result.offset_ = offset_; + } + if (((from_bitField0_ & 0x00000100) != 0)) { + result.autocut_ = autocut_; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + result.after_ = after_; + } + if (((from_bitField0_ & 0x00000800) != 0)) { + result.filters_ = filtersBuilder_ == null + ? filters_ + : filtersBuilder_.build(); + to_bitField0_ |= 0x00000010; + } + if (((from_bitField0_ & 0x00001000) != 0)) { + result.hybridSearch_ = hybridSearchBuilder_ == null + ? hybridSearch_ + : hybridSearchBuilder_.build(); + to_bitField0_ |= 0x00000020; + } + if (((from_bitField0_ & 0x00002000) != 0)) { + result.bm25Search_ = bm25SearchBuilder_ == null + ? bm25Search_ + : bm25SearchBuilder_.build(); + to_bitField0_ |= 0x00000040; + } + if (((from_bitField0_ & 0x00004000) != 0)) { + result.nearVector_ = nearVectorBuilder_ == null + ? nearVector_ + : nearVectorBuilder_.build(); + to_bitField0_ |= 0x00000080; + } + if (((from_bitField0_ & 0x00008000) != 0)) { + result.nearObject_ = nearObjectBuilder_ == null + ? nearObject_ + : nearObjectBuilder_.build(); + to_bitField0_ |= 0x00000100; + } + if (((from_bitField0_ & 0x00010000) != 0)) { + result.nearText_ = nearTextBuilder_ == null + ? nearText_ + : nearTextBuilder_.build(); + to_bitField0_ |= 0x00000200; + } + if (((from_bitField0_ & 0x00020000) != 0)) { + result.nearImage_ = nearImageBuilder_ == null + ? nearImage_ + : nearImageBuilder_.build(); + to_bitField0_ |= 0x00000400; + } + if (((from_bitField0_ & 0x00040000) != 0)) { + result.nearAudio_ = nearAudioBuilder_ == null + ? nearAudio_ + : nearAudioBuilder_.build(); + to_bitField0_ |= 0x00000800; + } + if (((from_bitField0_ & 0x00080000) != 0)) { + result.nearVideo_ = nearVideoBuilder_ == null + ? nearVideo_ + : nearVideoBuilder_.build(); + to_bitField0_ |= 0x00001000; + } + if (((from_bitField0_ & 0x00100000) != 0)) { + result.nearDepth_ = nearDepthBuilder_ == null + ? nearDepth_ + : nearDepthBuilder_.build(); + to_bitField0_ |= 0x00002000; + } + if (((from_bitField0_ & 0x00200000) != 0)) { + result.nearThermal_ = nearThermalBuilder_ == null + ? nearThermal_ + : nearThermalBuilder_.build(); + to_bitField0_ |= 0x00004000; + } + if (((from_bitField0_ & 0x00400000) != 0)) { + result.nearImu_ = nearImuBuilder_ == null + ? nearImu_ + : nearImuBuilder_.build(); + to_bitField0_ |= 0x00008000; + } + if (((from_bitField0_ & 0x00800000) != 0)) { + result.generative_ = generativeBuilder_ == null + ? generative_ + : generativeBuilder_.build(); + to_bitField0_ |= 0x00010000; + } + if (((from_bitField0_ & 0x01000000) != 0)) { + result.rerank_ = rerankBuilder_ == null + ? rerank_ + : rerankBuilder_.build(); + to_bitField0_ |= 0x00020000; + } + if (((from_bitField0_ & 0x02000000) != 0)) { + result.uses123Api_ = uses123Api_; + } + if (((from_bitField0_ & 0x04000000) != 0)) { + result.uses125Api_ = uses125Api_; + } + if (((from_bitField0_ & 0x08000000) != 0)) { + result.uses127Api_ = uses127Api_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest.getDefaultInstance()) return this; + if (!other.getCollection().isEmpty()) { + collection_ = other.collection_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.getTenant().isEmpty()) { + tenant_ = other.tenant_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (other.hasConsistencyLevel()) { + setConsistencyLevel(other.getConsistencyLevel()); + } + if (other.hasProperties()) { + mergeProperties(other.getProperties()); + } + if (other.hasMetadata()) { + mergeMetadata(other.getMetadata()); + } + if (other.hasGroupBy()) { + mergeGroupBy(other.getGroupBy()); + } + if (other.getLimit() != 0) { + setLimit(other.getLimit()); + } + if (other.getOffset() != 0) { + setOffset(other.getOffset()); + } + if (other.getAutocut() != 0) { + setAutocut(other.getAutocut()); + } + if (!other.getAfter().isEmpty()) { + after_ = other.after_; + bitField0_ |= 0x00000200; + onChanged(); + } + if (sortByBuilder_ == null) { + if (!other.sortBy_.isEmpty()) { + if (sortBy_.isEmpty()) { + sortBy_ = other.sortBy_; + bitField0_ = (bitField0_ & ~0x00000400); + } else { + ensureSortByIsMutable(); + sortBy_.addAll(other.sortBy_); + } + onChanged(); + } + } else { + if (!other.sortBy_.isEmpty()) { + if (sortByBuilder_.isEmpty()) { + sortByBuilder_.dispose(); + sortByBuilder_ = null; + sortBy_ = other.sortBy_; + bitField0_ = (bitField0_ & ~0x00000400); + sortByBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getSortByFieldBuilder() : null; + } else { + sortByBuilder_.addAllMessages(other.sortBy_); + } + } + } + if (other.hasFilters()) { + mergeFilters(other.getFilters()); + } + if (other.hasHybridSearch()) { + mergeHybridSearch(other.getHybridSearch()); + } + if (other.hasBm25Search()) { + mergeBm25Search(other.getBm25Search()); + } + if (other.hasNearVector()) { + mergeNearVector(other.getNearVector()); + } + if (other.hasNearObject()) { + mergeNearObject(other.getNearObject()); + } + if (other.hasNearText()) { + mergeNearText(other.getNearText()); + } + if (other.hasNearImage()) { + mergeNearImage(other.getNearImage()); + } + if (other.hasNearAudio()) { + mergeNearAudio(other.getNearAudio()); + } + if (other.hasNearVideo()) { + mergeNearVideo(other.getNearVideo()); + } + if (other.hasNearDepth()) { + mergeNearDepth(other.getNearDepth()); + } + if (other.hasNearThermal()) { + mergeNearThermal(other.getNearThermal()); + } + if (other.hasNearImu()) { + mergeNearImu(other.getNearImu()); + } + if (other.hasGenerative()) { + mergeGenerative(other.getGenerative()); + } + if (other.hasRerank()) { + mergeRerank(other.getRerank()); + } + if (other.getUses123Api() != false) { + setUses123Api(other.getUses123Api()); + } + if (other.getUses125Api() != false) { + setUses125Api(other.getUses125Api()); + } + if (other.getUses127Api() != false) { + setUses127Api(other.getUses127Api()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + collection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 82: { + tenant_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 82 + case 88: { + consistencyLevel_ = input.readEnum(); + bitField0_ |= 0x00000004; + break; + } // case 88 + case 162: { + input.readMessage( + getPropertiesFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000008; + break; + } // case 162 + case 170: { + input.readMessage( + getMetadataFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000010; + break; + } // case 170 + case 178: { + input.readMessage( + getGroupByFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000020; + break; + } // case 178 + case 240: { + limit_ = input.readUInt32(); + bitField0_ |= 0x00000040; + break; + } // case 240 + case 248: { + offset_ = input.readUInt32(); + bitField0_ |= 0x00000080; + break; + } // case 248 + case 256: { + autocut_ = input.readUInt32(); + bitField0_ |= 0x00000100; + break; + } // case 256 + case 266: { + after_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000200; + break; + } // case 266 + case 274: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.parser(), + extensionRegistry); + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + sortBy_.add(m); + } else { + sortByBuilder_.addMessage(m); + } + break; + } // case 274 + case 322: { + input.readMessage( + getFiltersFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000800; + break; + } // case 322 + case 330: { + input.readMessage( + getHybridSearchFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00001000; + break; + } // case 330 + case 338: { + input.readMessage( + getBm25SearchFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00002000; + break; + } // case 338 + case 346: { + input.readMessage( + getNearVectorFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00004000; + break; + } // case 346 + case 354: { + input.readMessage( + getNearObjectFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00008000; + break; + } // case 354 + case 362: { + input.readMessage( + getNearTextFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00010000; + break; + } // case 362 + case 370: { + input.readMessage( + getNearImageFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00020000; + break; + } // case 370 + case 378: { + input.readMessage( + getNearAudioFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00040000; + break; + } // case 378 + case 386: { + input.readMessage( + getNearVideoFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00080000; + break; + } // case 386 + case 394: { + input.readMessage( + getNearDepthFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00100000; + break; + } // case 394 + case 402: { + input.readMessage( + getNearThermalFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00200000; + break; + } // case 402 + case 410: { + input.readMessage( + getNearImuFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00400000; + break; + } // case 410 + case 482: { + input.readMessage( + getGenerativeFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00800000; + break; + } // case 482 + case 490: { + input.readMessage( + getRerankFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x01000000; + break; + } // case 490 + case 800: { + uses123Api_ = input.readBool(); + bitField0_ |= 0x02000000; + break; + } // case 800 + case 808: { + uses125Api_ = input.readBool(); + bitField0_ |= 0x04000000; + break; + } // case 808 + case 816: { + uses127Api_ = input.readBool(); + bitField0_ |= 0x08000000; + break; + } // case 816 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object collection_ = ""; + /** + *
+       *required
+       * 
+ * + * string collection = 1; + * @return The collection. + */ + public java.lang.String getCollection() { + java.lang.Object ref = collection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + collection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + *
+       *required
+       * 
+ * + * string collection = 1; + * @return The bytes for collection. + */ + public com.google.protobuf.ByteString + getCollectionBytes() { + java.lang.Object ref = collection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + collection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + *
+       *required
+       * 
+ * + * string collection = 1; + * @param value The collection to set. + * @return This builder for chaining. + */ + public Builder setCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + collection_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       *required
+       * 
+ * + * string collection = 1; + * @return This builder for chaining. + */ + public Builder clearCollection() { + collection_ = getDefaultInstance().getCollection(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + *
+       *required
+       * 
+ * + * string collection = 1; + * @param value The bytes for collection to set. + * @return This builder for chaining. + */ + public Builder setCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + collection_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object tenant_ = ""; + /** + *
+       * parameters
+       * 
+ * + * string tenant = 10; + * @return The tenant. + */ + public java.lang.String getTenant() { + java.lang.Object ref = tenant_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + tenant_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + *
+       * parameters
+       * 
+ * + * string tenant = 10; + * @return The bytes for tenant. + */ + public com.google.protobuf.ByteString + getTenantBytes() { + java.lang.Object ref = tenant_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tenant_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + *
+       * parameters
+       * 
+ * + * string tenant = 10; + * @param value The tenant to set. + * @return This builder for chaining. + */ + public Builder setTenant( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + tenant_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * parameters
+       * 
+ * + * string tenant = 10; + * @return This builder for chaining. + */ + public Builder clearTenant() { + tenant_ = getDefaultInstance().getTenant(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + *
+       * parameters
+       * 
+ * + * string tenant = 10; + * @param value The bytes for tenant to set. + * @return This builder for chaining. + */ + public Builder setTenantBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + tenant_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private int consistencyLevel_ = 0; + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return Whether the consistencyLevel field is set. + */ + @java.lang.Override public boolean hasConsistencyLevel() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The enum numeric value on the wire for consistencyLevel. + */ + @java.lang.Override public int getConsistencyLevelValue() { + return consistencyLevel_; + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @param value The enum numeric value on the wire for consistencyLevel to set. + * @return This builder for chaining. + */ + public Builder setConsistencyLevelValue(int value) { + consistencyLevel_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return The consistencyLevel. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel getConsistencyLevel() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.forNumber(consistencyLevel_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel.UNRECOGNIZED : result; + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @param value The consistencyLevel to set. + * @return This builder for chaining. + */ + public Builder setConsistencyLevel(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.ConsistencyLevel value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + consistencyLevel_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .weaviate.v1.ConsistencyLevel consistency_level = 11; + * @return This builder for chaining. + */ + public Builder clearConsistencyLevel() { + bitField0_ = (bitField0_ & ~0x00000004); + consistencyLevel_ = 0; + onChanged(); + return this; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest properties_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> propertiesBuilder_; + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return Whether the properties field is set. + */ + public boolean hasProperties() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + * @return The properties. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties() { + if (propertiesBuilder_ == null) { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } else { + return propertiesBuilder_.getMessage(); + } + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public Builder setProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + properties_ = value; + } else { + propertiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public Builder setProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder builderForValue) { + if (propertiesBuilder_ == null) { + properties_ = builderForValue.build(); + } else { + propertiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public Builder mergeProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest value) { + if (propertiesBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + properties_ != null && + properties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) { + getPropertiesBuilder().mergeFrom(value); + } else { + properties_ = value; + } + } else { + propertiesBuilder_.mergeFrom(value); + } + if (properties_ != null) { + bitField0_ |= 0x00000008; + onChanged(); + } + return this; + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public Builder clearProperties() { + bitField0_ = (bitField0_ & ~0x00000008); + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + onChanged(); + return this; + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder getPropertiesBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getPropertiesFieldBuilder().getBuilder(); + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { + if (propertiesBuilder_ != null) { + return propertiesBuilder_.getMessageOrBuilder(); + } else { + return properties_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + } + /** + *
+       * what is returned
+       * 
+ * + * optional .weaviate.v1.PropertiesRequest properties = 20; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> + getPropertiesFieldBuilder() { + if (propertiesBuilder_ == null) { + propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder>( + getProperties(), + getParentForChildren(), + isClean()); + properties_ = null; + } + return propertiesBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest metadata_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder> metadataBuilder_; + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return Whether the metadata field is set. + */ + public boolean hasMetadata() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + * @return The metadata. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata() { + if (metadataBuilder_ == null) { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } else { + return metadataBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest value) { + if (metadataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + metadata_ = value; + } else { + metadataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public Builder setMetadata( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder builderForValue) { + if (metadataBuilder_ == null) { + metadata_ = builderForValue.build(); + } else { + metadataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest value) { + if (metadataBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0) && + metadata_ != null && + metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) { + getMetadataBuilder().mergeFrom(value); + } else { + metadata_ = value; + } + } else { + metadataBuilder_.mergeFrom(value); + } + if (metadata_ != null) { + bitField0_ |= 0x00000010; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public Builder clearMetadata() { + bitField0_ = (bitField0_ & ~0x00000010); + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder getMetadataBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getMetadataFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { + if (metadataBuilder_ != null) { + return metadataBuilder_.getMessageOrBuilder(); + } else { + return metadata_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + } + /** + * optional .weaviate.v1.MetadataRequest metadata = 21; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder> + getMetadataFieldBuilder() { + if (metadataBuilder_ == null) { + metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder>( + getMetadata(), + getParentForChildren(), + isClean()); + metadata_ = null; + } + return metadataBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy groupBy_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder> groupByBuilder_; + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return Whether the groupBy field is set. + */ + public boolean hasGroupBy() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + * @return The groupBy. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getGroupBy() { + if (groupByBuilder_ == null) { + return groupBy_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; + } else { + return groupByBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public Builder setGroupBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy value) { + if (groupByBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + groupBy_ = value; + } else { + groupByBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public Builder setGroupBy( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder builderForValue) { + if (groupByBuilder_ == null) { + groupBy_ = builderForValue.build(); + } else { + groupByBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public Builder mergeGroupBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy value) { + if (groupByBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0) && + groupBy_ != null && + groupBy_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance()) { + getGroupByBuilder().mergeFrom(value); + } else { + groupBy_ = value; + } + } else { + groupByBuilder_.mergeFrom(value); + } + if (groupBy_ != null) { + bitField0_ |= 0x00000020; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public Builder clearGroupBy() { + bitField0_ = (bitField0_ & ~0x00000020); + groupBy_ = null; + if (groupByBuilder_ != null) { + groupByBuilder_.dispose(); + groupByBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder getGroupByBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getGroupByFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder getGroupByOrBuilder() { + if (groupByBuilder_ != null) { + return groupByBuilder_.getMessageOrBuilder(); + } else { + return groupBy_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance() : groupBy_; + } + } + /** + * optional .weaviate.v1.GroupBy group_by = 22; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder> + getGroupByFieldBuilder() { + if (groupByBuilder_ == null) { + groupByBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder>( + getGroupBy(), + getParentForChildren(), + isClean()); + groupBy_ = null; + } + return groupByBuilder_; + } + + private int limit_ ; + /** + *
+       * affects order and length of results. 0/empty (default value) means disabled
+       * 
+ * + * uint32 limit = 30; + * @return The limit. + */ + @java.lang.Override + public int getLimit() { + return limit_; + } + /** + *
+       * affects order and length of results. 0/empty (default value) means disabled
+       * 
+ * + * uint32 limit = 30; + * @param value The limit to set. + * @return This builder for chaining. + */ + public Builder setLimit(int value) { + + limit_ = value; + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + *
+       * affects order and length of results. 0/empty (default value) means disabled
+       * 
+ * + * uint32 limit = 30; + * @return This builder for chaining. + */ + public Builder clearLimit() { + bitField0_ = (bitField0_ & ~0x00000040); + limit_ = 0; + onChanged(); + return this; + } + + private int offset_ ; + /** + * uint32 offset = 31; + * @return The offset. + */ + @java.lang.Override + public int getOffset() { + return offset_; + } + /** + * uint32 offset = 31; + * @param value The offset to set. + * @return This builder for chaining. + */ + public Builder setOffset(int value) { + + offset_ = value; + bitField0_ |= 0x00000080; + onChanged(); + return this; + } + /** + * uint32 offset = 31; + * @return This builder for chaining. + */ + public Builder clearOffset() { + bitField0_ = (bitField0_ & ~0x00000080); + offset_ = 0; + onChanged(); + return this; + } + + private int autocut_ ; + /** + * uint32 autocut = 32; + * @return The autocut. + */ + @java.lang.Override + public int getAutocut() { + return autocut_; + } + /** + * uint32 autocut = 32; + * @param value The autocut to set. + * @return This builder for chaining. + */ + public Builder setAutocut(int value) { + + autocut_ = value; + bitField0_ |= 0x00000100; + onChanged(); + return this; + } + /** + * uint32 autocut = 32; + * @return This builder for chaining. + */ + public Builder clearAutocut() { + bitField0_ = (bitField0_ & ~0x00000100); + autocut_ = 0; + onChanged(); + return this; + } + + private java.lang.Object after_ = ""; + /** + * string after = 33; + * @return The after. + */ + public java.lang.String getAfter() { + java.lang.Object ref = after_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + after_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string after = 33; + * @return The bytes for after. + */ + public com.google.protobuf.ByteString + getAfterBytes() { + java.lang.Object ref = after_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + after_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string after = 33; + * @param value The after to set. + * @return This builder for chaining. + */ + public Builder setAfter( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + after_ = value; + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + * string after = 33; + * @return This builder for chaining. + */ + public Builder clearAfter() { + after_ = getDefaultInstance().getAfter(); + bitField0_ = (bitField0_ & ~0x00000200); + onChanged(); + return this; + } + /** + * string after = 33; + * @param value The bytes for after to set. + * @return This builder for chaining. + */ + public Builder setAfterBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + after_ = value; + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + + private java.util.List sortBy_ = + java.util.Collections.emptyList(); + private void ensureSortByIsMutable() { + if (!((bitField0_ & 0x00000400) != 0)) { + sortBy_ = new java.util.ArrayList(sortBy_); + bitField0_ |= 0x00000400; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder> sortByBuilder_; + + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public java.util.List getSortByList() { + if (sortByBuilder_ == null) { + return java.util.Collections.unmodifiableList(sortBy_); + } else { + return sortByBuilder_.getMessageList(); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public int getSortByCount() { + if (sortByBuilder_ == null) { + return sortBy_.size(); + } else { + return sortByBuilder_.getCount(); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getSortBy(int index) { + if (sortByBuilder_ == null) { + return sortBy_.get(index); + } else { + return sortByBuilder_.getMessage(index); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder setSortBy( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy value) { + if (sortByBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSortByIsMutable(); + sortBy_.set(index, value); + onChanged(); + } else { + sortByBuilder_.setMessage(index, value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder setSortBy( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + sortBy_.set(index, builderForValue.build()); + onChanged(); + } else { + sortByBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder addSortBy(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy value) { + if (sortByBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSortByIsMutable(); + sortBy_.add(value); + onChanged(); + } else { + sortByBuilder_.addMessage(value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder addSortBy( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy value) { + if (sortByBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSortByIsMutable(); + sortBy_.add(index, value); + onChanged(); + } else { + sortByBuilder_.addMessage(index, value); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder addSortBy( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + sortBy_.add(builderForValue.build()); + onChanged(); + } else { + sortByBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder addSortBy( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder builderForValue) { + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + sortBy_.add(index, builderForValue.build()); + onChanged(); + } else { + sortByBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder addAllSortBy( + java.lang.Iterable values) { + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, sortBy_); + onChanged(); + } else { + sortByBuilder_.addAllMessages(values); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder clearSortBy() { + if (sortByBuilder_ == null) { + sortBy_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000400); + onChanged(); + } else { + sortByBuilder_.clear(); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public Builder removeSortBy(int index) { + if (sortByBuilder_ == null) { + ensureSortByIsMutable(); + sortBy_.remove(index); + onChanged(); + } else { + sortByBuilder_.remove(index); + } + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder getSortByBuilder( + int index) { + return getSortByFieldBuilder().getBuilder(index); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder getSortByOrBuilder( + int index) { + if (sortByBuilder_ == null) { + return sortBy_.get(index); } else { + return sortByBuilder_.getMessageOrBuilder(index); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public java.util.List + getSortByOrBuilderList() { + if (sortByBuilder_ != null) { + return sortByBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(sortBy_); + } + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder addSortByBuilder() { + return getSortByFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.getDefaultInstance()); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder addSortByBuilder( + int index) { + return getSortByFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.getDefaultInstance()); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated .weaviate.v1.SortBy sort_by = 34; + */ + public java.util.List + getSortByBuilderList() { + return getSortByFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder> + getSortByFieldBuilder() { + if (sortByBuilder_ == null) { + sortByBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder>( + sortBy_, + ((bitField0_ & 0x00000400) != 0), + getParentForChildren(), + isClean()); + sortBy_ = null; + } + return sortByBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters filters_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> filtersBuilder_; + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return Whether the filters field is set. + */ + public boolean hasFilters() { + return ((bitField0_ & 0x00000800) != 0); + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + * @return The filters. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters getFilters() { + if (filtersBuilder_ == null) { + return filters_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + } else { + return filtersBuilder_.getMessage(); + } + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public Builder setFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) { + if (filtersBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + filters_ = value; + } else { + filtersBuilder_.setMessage(value); + } + bitField0_ |= 0x00000800; + onChanged(); + return this; + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public Builder setFilters( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder builderForValue) { + if (filtersBuilder_ == null) { + filters_ = builderForValue.build(); + } else { + filtersBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000800; + onChanged(); + return this; + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public Builder mergeFilters(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters value) { + if (filtersBuilder_ == null) { + if (((bitField0_ & 0x00000800) != 0) && + filters_ != null && + filters_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance()) { + getFiltersBuilder().mergeFrom(value); + } else { + filters_ = value; + } + } else { + filtersBuilder_.mergeFrom(value); + } + if (filters_ != null) { + bitField0_ |= 0x00000800; + onChanged(); + } + return this; + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public Builder clearFilters() { + bitField0_ = (bitField0_ & ~0x00000800); + filters_ = null; + if (filtersBuilder_ != null) { + filtersBuilder_.dispose(); + filtersBuilder_ = null; + } + onChanged(); + return this; + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder getFiltersBuilder() { + bitField0_ |= 0x00000800; + onChanged(); + return getFiltersFieldBuilder().getBuilder(); + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder getFiltersOrBuilder() { + if (filtersBuilder_ != null) { + return filtersBuilder_.getMessageOrBuilder(); + } else { + return filters_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.getDefaultInstance() : filters_; + } + } + /** + *
+       * matches/searches for objects
+       * 
+ * + * optional .weaviate.v1.Filters filters = 40; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder> + getFiltersFieldBuilder() { + if (filtersBuilder_ == null) { + filtersBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Filters.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.FiltersOrBuilder>( + getFilters(), + getParentForChildren(), + isClean()); + filters_ = null; + } + return filtersBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid hybridSearch_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder> hybridSearchBuilder_; + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return Whether the hybridSearch field is set. + */ + public boolean hasHybridSearch() { + return ((bitField0_ & 0x00001000) != 0); + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + * @return The hybridSearch. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid getHybridSearch() { + if (hybridSearchBuilder_ == null) { + return hybridSearch_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; + } else { + return hybridSearchBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public Builder setHybridSearch(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid value) { + if (hybridSearchBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + hybridSearch_ = value; + } else { + hybridSearchBuilder_.setMessage(value); + } + bitField0_ |= 0x00001000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public Builder setHybridSearch( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder builderForValue) { + if (hybridSearchBuilder_ == null) { + hybridSearch_ = builderForValue.build(); + } else { + hybridSearchBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00001000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public Builder mergeHybridSearch(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid value) { + if (hybridSearchBuilder_ == null) { + if (((bitField0_ & 0x00001000) != 0) && + hybridSearch_ != null && + hybridSearch_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance()) { + getHybridSearchBuilder().mergeFrom(value); + } else { + hybridSearch_ = value; + } + } else { + hybridSearchBuilder_.mergeFrom(value); + } + if (hybridSearch_ != null) { + bitField0_ |= 0x00001000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public Builder clearHybridSearch() { + bitField0_ = (bitField0_ & ~0x00001000); + hybridSearch_ = null; + if (hybridSearchBuilder_ != null) { + hybridSearchBuilder_.dispose(); + hybridSearchBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder getHybridSearchBuilder() { + bitField0_ |= 0x00001000; + onChanged(); + return getHybridSearchFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder getHybridSearchOrBuilder() { + if (hybridSearchBuilder_ != null) { + return hybridSearchBuilder_.getMessageOrBuilder(); + } else { + return hybridSearch_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.getDefaultInstance() : hybridSearch_; + } + } + /** + * optional .weaviate.v1.Hybrid hybrid_search = 41; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder> + getHybridSearchFieldBuilder() { + if (hybridSearchBuilder_ == null) { + hybridSearchBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.Hybrid.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.HybridOrBuilder>( + getHybridSearch(), + getParentForChildren(), + isClean()); + hybridSearch_ = null; + } + return hybridSearchBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 bm25Search_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder> bm25SearchBuilder_; + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return Whether the bm25Search field is set. + */ + public boolean hasBm25Search() { + return ((bitField0_ & 0x00002000) != 0); + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + * @return The bm25Search. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 getBm25Search() { + if (bm25SearchBuilder_ == null) { + return bm25Search_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; + } else { + return bm25SearchBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public Builder setBm25Search(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 value) { + if (bm25SearchBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + bm25Search_ = value; + } else { + bm25SearchBuilder_.setMessage(value); + } + bitField0_ |= 0x00002000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public Builder setBm25Search( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder builderForValue) { + if (bm25SearchBuilder_ == null) { + bm25Search_ = builderForValue.build(); + } else { + bm25SearchBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00002000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public Builder mergeBm25Search(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25 value) { + if (bm25SearchBuilder_ == null) { + if (((bitField0_ & 0x00002000) != 0) && + bm25Search_ != null && + bm25Search_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance()) { + getBm25SearchBuilder().mergeFrom(value); + } else { + bm25Search_ = value; + } + } else { + bm25SearchBuilder_.mergeFrom(value); + } + if (bm25Search_ != null) { + bitField0_ |= 0x00002000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public Builder clearBm25Search() { + bitField0_ = (bitField0_ & ~0x00002000); + bm25Search_ = null; + if (bm25SearchBuilder_ != null) { + bm25SearchBuilder_.dispose(); + bm25SearchBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder getBm25SearchBuilder() { + bitField0_ |= 0x00002000; + onChanged(); + return getBm25SearchFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder getBm25SearchOrBuilder() { + if (bm25SearchBuilder_ != null) { + return bm25SearchBuilder_.getMessageOrBuilder(); + } else { + return bm25Search_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.getDefaultInstance() : bm25Search_; + } + } + /** + * optional .weaviate.v1.BM25 bm25_search = 42; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder> + getBm25SearchFieldBuilder() { + if (bm25SearchBuilder_ == null) { + bm25SearchBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.BM25OrBuilder>( + getBm25Search(), + getParentForChildren(), + isClean()); + bm25Search_ = null; + } + return bm25SearchBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector nearVector_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> nearVectorBuilder_; + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return Whether the nearVector field is set. + */ + public boolean hasNearVector() { + return ((bitField0_ & 0x00004000) != 0); + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + * @return The nearVector. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector getNearVector() { + if (nearVectorBuilder_ == null) { + return nearVector_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; + } else { + return nearVectorBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public Builder setNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) { + if (nearVectorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearVector_ = value; + } else { + nearVectorBuilder_.setMessage(value); + } + bitField0_ |= 0x00004000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public Builder setNearVector( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder builderForValue) { + if (nearVectorBuilder_ == null) { + nearVector_ = builderForValue.build(); + } else { + nearVectorBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00004000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public Builder mergeNearVector(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector value) { + if (nearVectorBuilder_ == null) { + if (((bitField0_ & 0x00004000) != 0) && + nearVector_ != null && + nearVector_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance()) { + getNearVectorBuilder().mergeFrom(value); + } else { + nearVector_ = value; + } + } else { + nearVectorBuilder_.mergeFrom(value); + } + if (nearVector_ != null) { + bitField0_ |= 0x00004000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public Builder clearNearVector() { + bitField0_ = (bitField0_ & ~0x00004000); + nearVector_ = null; + if (nearVectorBuilder_ != null) { + nearVectorBuilder_.dispose(); + nearVectorBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder getNearVectorBuilder() { + bitField0_ |= 0x00004000; + onChanged(); + return getNearVectorFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder getNearVectorOrBuilder() { + if (nearVectorBuilder_ != null) { + return nearVectorBuilder_.getMessageOrBuilder(); + } else { + return nearVector_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.getDefaultInstance() : nearVector_; + } + } + /** + * optional .weaviate.v1.NearVector near_vector = 43; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder> + getNearVectorFieldBuilder() { + if (nearVectorBuilder_ == null) { + nearVectorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVector.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVectorOrBuilder>( + getNearVector(), + getParentForChildren(), + isClean()); + nearVector_ = null; + } + return nearVectorBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject nearObject_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder> nearObjectBuilder_; + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return Whether the nearObject field is set. + */ + public boolean hasNearObject() { + return ((bitField0_ & 0x00008000) != 0); + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + * @return The nearObject. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject getNearObject() { + if (nearObjectBuilder_ == null) { + return nearObject_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; + } else { + return nearObjectBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public Builder setNearObject(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject value) { + if (nearObjectBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearObject_ = value; + } else { + nearObjectBuilder_.setMessage(value); + } + bitField0_ |= 0x00008000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public Builder setNearObject( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder builderForValue) { + if (nearObjectBuilder_ == null) { + nearObject_ = builderForValue.build(); + } else { + nearObjectBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00008000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public Builder mergeNearObject(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject value) { + if (nearObjectBuilder_ == null) { + if (((bitField0_ & 0x00008000) != 0) && + nearObject_ != null && + nearObject_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance()) { + getNearObjectBuilder().mergeFrom(value); + } else { + nearObject_ = value; + } + } else { + nearObjectBuilder_.mergeFrom(value); + } + if (nearObject_ != null) { + bitField0_ |= 0x00008000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public Builder clearNearObject() { + bitField0_ = (bitField0_ & ~0x00008000); + nearObject_ = null; + if (nearObjectBuilder_ != null) { + nearObjectBuilder_.dispose(); + nearObjectBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder getNearObjectBuilder() { + bitField0_ |= 0x00008000; + onChanged(); + return getNearObjectFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder getNearObjectOrBuilder() { + if (nearObjectBuilder_ != null) { + return nearObjectBuilder_.getMessageOrBuilder(); + } else { + return nearObject_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.getDefaultInstance() : nearObject_; + } + } + /** + * optional .weaviate.v1.NearObject near_object = 44; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder> + getNearObjectFieldBuilder() { + if (nearObjectBuilder_ == null) { + nearObjectBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObject.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearObjectOrBuilder>( + getNearObject(), + getParentForChildren(), + isClean()); + nearObject_ = null; + } + return nearObjectBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch nearText_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> nearTextBuilder_; + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return Whether the nearText field is set. + */ + public boolean hasNearText() { + return ((bitField0_ & 0x00010000) != 0); + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + * @return The nearText. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch getNearText() { + if (nearTextBuilder_ == null) { + return nearText_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; + } else { + return nearTextBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public Builder setNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) { + if (nearTextBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearText_ = value; + } else { + nearTextBuilder_.setMessage(value); + } + bitField0_ |= 0x00010000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public Builder setNearText( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder builderForValue) { + if (nearTextBuilder_ == null) { + nearText_ = builderForValue.build(); + } else { + nearTextBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00010000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public Builder mergeNearText(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch value) { + if (nearTextBuilder_ == null) { + if (((bitField0_ & 0x00010000) != 0) && + nearText_ != null && + nearText_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance()) { + getNearTextBuilder().mergeFrom(value); + } else { + nearText_ = value; + } + } else { + nearTextBuilder_.mergeFrom(value); + } + if (nearText_ != null) { + bitField0_ |= 0x00010000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public Builder clearNearText() { + bitField0_ = (bitField0_ & ~0x00010000); + nearText_ = null; + if (nearTextBuilder_ != null) { + nearTextBuilder_.dispose(); + nearTextBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder getNearTextBuilder() { + bitField0_ |= 0x00010000; + onChanged(); + return getNearTextFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder getNearTextOrBuilder() { + if (nearTextBuilder_ != null) { + return nearTextBuilder_.getMessageOrBuilder(); + } else { + return nearText_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.getDefaultInstance() : nearText_; + } + } + /** + * optional .weaviate.v1.NearTextSearch near_text = 45; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder> + getNearTextFieldBuilder() { + if (nearTextBuilder_ == null) { + nearTextBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearTextSearchOrBuilder>( + getNearText(), + getParentForChildren(), + isClean()); + nearText_ = null; + } + return nearTextBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch nearImage_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> nearImageBuilder_; + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return Whether the nearImage field is set. + */ + public boolean hasNearImage() { + return ((bitField0_ & 0x00020000) != 0); + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + * @return The nearImage. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch getNearImage() { + if (nearImageBuilder_ == null) { + return nearImage_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; + } else { + return nearImageBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public Builder setNearImage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch value) { + if (nearImageBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearImage_ = value; + } else { + nearImageBuilder_.setMessage(value); + } + bitField0_ |= 0x00020000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public Builder setNearImage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder builderForValue) { + if (nearImageBuilder_ == null) { + nearImage_ = builderForValue.build(); + } else { + nearImageBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00020000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public Builder mergeNearImage(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch value) { + if (nearImageBuilder_ == null) { + if (((bitField0_ & 0x00020000) != 0) && + nearImage_ != null && + nearImage_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance()) { + getNearImageBuilder().mergeFrom(value); + } else { + nearImage_ = value; + } + } else { + nearImageBuilder_.mergeFrom(value); + } + if (nearImage_ != null) { + bitField0_ |= 0x00020000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public Builder clearNearImage() { + bitField0_ = (bitField0_ & ~0x00020000); + nearImage_ = null; + if (nearImageBuilder_ != null) { + nearImageBuilder_.dispose(); + nearImageBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder getNearImageBuilder() { + bitField0_ |= 0x00020000; + onChanged(); + return getNearImageFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder getNearImageOrBuilder() { + if (nearImageBuilder_ != null) { + return nearImageBuilder_.getMessageOrBuilder(); + } else { + return nearImage_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.getDefaultInstance() : nearImage_; + } + } + /** + * optional .weaviate.v1.NearImageSearch near_image = 46; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder> + getNearImageFieldBuilder() { + if (nearImageBuilder_ == null) { + nearImageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearImageSearchOrBuilder>( + getNearImage(), + getParentForChildren(), + isClean()); + nearImage_ = null; + } + return nearImageBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch nearAudio_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> nearAudioBuilder_; + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return Whether the nearAudio field is set. + */ + public boolean hasNearAudio() { + return ((bitField0_ & 0x00040000) != 0); + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + * @return The nearAudio. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch getNearAudio() { + if (nearAudioBuilder_ == null) { + return nearAudio_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; + } else { + return nearAudioBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public Builder setNearAudio(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch value) { + if (nearAudioBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearAudio_ = value; + } else { + nearAudioBuilder_.setMessage(value); + } + bitField0_ |= 0x00040000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public Builder setNearAudio( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder builderForValue) { + if (nearAudioBuilder_ == null) { + nearAudio_ = builderForValue.build(); + } else { + nearAudioBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00040000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public Builder mergeNearAudio(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch value) { + if (nearAudioBuilder_ == null) { + if (((bitField0_ & 0x00040000) != 0) && + nearAudio_ != null && + nearAudio_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance()) { + getNearAudioBuilder().mergeFrom(value); + } else { + nearAudio_ = value; + } + } else { + nearAudioBuilder_.mergeFrom(value); + } + if (nearAudio_ != null) { + bitField0_ |= 0x00040000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public Builder clearNearAudio() { + bitField0_ = (bitField0_ & ~0x00040000); + nearAudio_ = null; + if (nearAudioBuilder_ != null) { + nearAudioBuilder_.dispose(); + nearAudioBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder getNearAudioBuilder() { + bitField0_ |= 0x00040000; + onChanged(); + return getNearAudioFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder getNearAudioOrBuilder() { + if (nearAudioBuilder_ != null) { + return nearAudioBuilder_.getMessageOrBuilder(); + } else { + return nearAudio_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.getDefaultInstance() : nearAudio_; + } + } + /** + * optional .weaviate.v1.NearAudioSearch near_audio = 47; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder> + getNearAudioFieldBuilder() { + if (nearAudioBuilder_ == null) { + nearAudioBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearAudioSearchOrBuilder>( + getNearAudio(), + getParentForChildren(), + isClean()); + nearAudio_ = null; + } + return nearAudioBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch nearVideo_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> nearVideoBuilder_; + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return Whether the nearVideo field is set. + */ + public boolean hasNearVideo() { + return ((bitField0_ & 0x00080000) != 0); + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + * @return The nearVideo. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch getNearVideo() { + if (nearVideoBuilder_ == null) { + return nearVideo_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; + } else { + return nearVideoBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public Builder setNearVideo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch value) { + if (nearVideoBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearVideo_ = value; + } else { + nearVideoBuilder_.setMessage(value); + } + bitField0_ |= 0x00080000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public Builder setNearVideo( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder builderForValue) { + if (nearVideoBuilder_ == null) { + nearVideo_ = builderForValue.build(); + } else { + nearVideoBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00080000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public Builder mergeNearVideo(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch value) { + if (nearVideoBuilder_ == null) { + if (((bitField0_ & 0x00080000) != 0) && + nearVideo_ != null && + nearVideo_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance()) { + getNearVideoBuilder().mergeFrom(value); + } else { + nearVideo_ = value; + } + } else { + nearVideoBuilder_.mergeFrom(value); + } + if (nearVideo_ != null) { + bitField0_ |= 0x00080000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public Builder clearNearVideo() { + bitField0_ = (bitField0_ & ~0x00080000); + nearVideo_ = null; + if (nearVideoBuilder_ != null) { + nearVideoBuilder_.dispose(); + nearVideoBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder getNearVideoBuilder() { + bitField0_ |= 0x00080000; + onChanged(); + return getNearVideoFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder getNearVideoOrBuilder() { + if (nearVideoBuilder_ != null) { + return nearVideoBuilder_.getMessageOrBuilder(); + } else { + return nearVideo_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.getDefaultInstance() : nearVideo_; + } + } + /** + * optional .weaviate.v1.NearVideoSearch near_video = 48; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder> + getNearVideoFieldBuilder() { + if (nearVideoBuilder_ == null) { + nearVideoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearVideoSearchOrBuilder>( + getNearVideo(), + getParentForChildren(), + isClean()); + nearVideo_ = null; + } + return nearVideoBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch nearDepth_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> nearDepthBuilder_; + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return Whether the nearDepth field is set. + */ + public boolean hasNearDepth() { + return ((bitField0_ & 0x00100000) != 0); + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + * @return The nearDepth. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch getNearDepth() { + if (nearDepthBuilder_ == null) { + return nearDepth_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; + } else { + return nearDepthBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public Builder setNearDepth(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch value) { + if (nearDepthBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearDepth_ = value; + } else { + nearDepthBuilder_.setMessage(value); + } + bitField0_ |= 0x00100000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public Builder setNearDepth( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder builderForValue) { + if (nearDepthBuilder_ == null) { + nearDepth_ = builderForValue.build(); + } else { + nearDepthBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00100000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public Builder mergeNearDepth(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch value) { + if (nearDepthBuilder_ == null) { + if (((bitField0_ & 0x00100000) != 0) && + nearDepth_ != null && + nearDepth_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance()) { + getNearDepthBuilder().mergeFrom(value); + } else { + nearDepth_ = value; + } + } else { + nearDepthBuilder_.mergeFrom(value); + } + if (nearDepth_ != null) { + bitField0_ |= 0x00100000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public Builder clearNearDepth() { + bitField0_ = (bitField0_ & ~0x00100000); + nearDepth_ = null; + if (nearDepthBuilder_ != null) { + nearDepthBuilder_.dispose(); + nearDepthBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder getNearDepthBuilder() { + bitField0_ |= 0x00100000; + onChanged(); + return getNearDepthFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder getNearDepthOrBuilder() { + if (nearDepthBuilder_ != null) { + return nearDepthBuilder_.getMessageOrBuilder(); + } else { + return nearDepth_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.getDefaultInstance() : nearDepth_; + } + } + /** + * optional .weaviate.v1.NearDepthSearch near_depth = 49; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder> + getNearDepthFieldBuilder() { + if (nearDepthBuilder_ == null) { + nearDepthBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearDepthSearchOrBuilder>( + getNearDepth(), + getParentForChildren(), + isClean()); + nearDepth_ = null; + } + return nearDepthBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch nearThermal_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> nearThermalBuilder_; + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return Whether the nearThermal field is set. + */ + public boolean hasNearThermal() { + return ((bitField0_ & 0x00200000) != 0); + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + * @return The nearThermal. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch getNearThermal() { + if (nearThermalBuilder_ == null) { + return nearThermal_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; + } else { + return nearThermalBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public Builder setNearThermal(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch value) { + if (nearThermalBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearThermal_ = value; + } else { + nearThermalBuilder_.setMessage(value); + } + bitField0_ |= 0x00200000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public Builder setNearThermal( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder builderForValue) { + if (nearThermalBuilder_ == null) { + nearThermal_ = builderForValue.build(); + } else { + nearThermalBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00200000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public Builder mergeNearThermal(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch value) { + if (nearThermalBuilder_ == null) { + if (((bitField0_ & 0x00200000) != 0) && + nearThermal_ != null && + nearThermal_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance()) { + getNearThermalBuilder().mergeFrom(value); + } else { + nearThermal_ = value; + } + } else { + nearThermalBuilder_.mergeFrom(value); + } + if (nearThermal_ != null) { + bitField0_ |= 0x00200000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public Builder clearNearThermal() { + bitField0_ = (bitField0_ & ~0x00200000); + nearThermal_ = null; + if (nearThermalBuilder_ != null) { + nearThermalBuilder_.dispose(); + nearThermalBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder getNearThermalBuilder() { + bitField0_ |= 0x00200000; + onChanged(); + return getNearThermalFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder getNearThermalOrBuilder() { + if (nearThermalBuilder_ != null) { + return nearThermalBuilder_.getMessageOrBuilder(); + } else { + return nearThermal_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.getDefaultInstance() : nearThermal_; + } + } + /** + * optional .weaviate.v1.NearThermalSearch near_thermal = 50; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder> + getNearThermalFieldBuilder() { + if (nearThermalBuilder_ == null) { + nearThermalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearThermalSearchOrBuilder>( + getNearThermal(), + getParentForChildren(), + isClean()); + nearThermal_ = null; + } + return nearThermalBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch nearImu_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> nearImuBuilder_; + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return Whether the nearImu field is set. + */ + public boolean hasNearImu() { + return ((bitField0_ & 0x00400000) != 0); + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + * @return The nearImu. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch getNearImu() { + if (nearImuBuilder_ == null) { + return nearImu_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; + } else { + return nearImuBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public Builder setNearImu(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch value) { + if (nearImuBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nearImu_ = value; + } else { + nearImuBuilder_.setMessage(value); + } + bitField0_ |= 0x00400000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public Builder setNearImu( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder builderForValue) { + if (nearImuBuilder_ == null) { + nearImu_ = builderForValue.build(); + } else { + nearImuBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00400000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public Builder mergeNearImu(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch value) { + if (nearImuBuilder_ == null) { + if (((bitField0_ & 0x00400000) != 0) && + nearImu_ != null && + nearImu_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance()) { + getNearImuBuilder().mergeFrom(value); + } else { + nearImu_ = value; + } + } else { + nearImuBuilder_.mergeFrom(value); + } + if (nearImu_ != null) { + bitField0_ |= 0x00400000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public Builder clearNearImu() { + bitField0_ = (bitField0_ & ~0x00400000); + nearImu_ = null; + if (nearImuBuilder_ != null) { + nearImuBuilder_.dispose(); + nearImuBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder getNearImuBuilder() { + bitField0_ |= 0x00400000; + onChanged(); + return getNearImuFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder getNearImuOrBuilder() { + if (nearImuBuilder_ != null) { + return nearImuBuilder_.getMessageOrBuilder(); + } else { + return nearImu_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.getDefaultInstance() : nearImu_; + } + } + /** + * optional .weaviate.v1.NearIMUSearch near_imu = 51; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder> + getNearImuFieldBuilder() { + if (nearImuBuilder_ == null) { + nearImuBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.NearIMUSearchOrBuilder>( + getNearImu(), + getParentForChildren(), + isClean()); + nearImu_ = null; + } + return nearImuBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch generative_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder> generativeBuilder_; + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return Whether the generative field is set. + */ + public boolean hasGenerative() { + return ((bitField0_ & 0x00800000) != 0); + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + * @return The generative. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch getGenerative() { + if (generativeBuilder_ == null) { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; + } else { + return generativeBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public Builder setGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch value) { + if (generativeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + generative_ = value; + } else { + generativeBuilder_.setMessage(value); + } + bitField0_ |= 0x00800000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public Builder setGenerative( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder builderForValue) { + if (generativeBuilder_ == null) { + generative_ = builderForValue.build(); + } else { + generativeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00800000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public Builder mergeGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch value) { + if (generativeBuilder_ == null) { + if (((bitField0_ & 0x00800000) != 0) && + generative_ != null && + generative_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance()) { + getGenerativeBuilder().mergeFrom(value); + } else { + generative_ = value; + } + } else { + generativeBuilder_.mergeFrom(value); + } + if (generative_ != null) { + bitField0_ |= 0x00800000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public Builder clearGenerative() { + bitField0_ = (bitField0_ & ~0x00800000); + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder getGenerativeBuilder() { + bitField0_ |= 0x00800000; + onChanged(); + return getGenerativeFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder getGenerativeOrBuilder() { + if (generativeBuilder_ != null) { + return generativeBuilder_.getMessageOrBuilder(); + } else { + return generative_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.getDefaultInstance() : generative_; + } + } + /** + * optional .weaviate.v1.GenerativeSearch generative = 60; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder> + getGenerativeFieldBuilder() { + if (generativeBuilder_ == null) { + generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearch.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeSearchOrBuilder>( + getGenerative(), + getParentForChildren(), + isClean()); + generative_ = null; + } + return generativeBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank rerank_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder> rerankBuilder_; + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return Whether the rerank field is set. + */ + public boolean hasRerank() { + return ((bitField0_ & 0x01000000) != 0); + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + * @return The rerank. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getRerank() { + if (rerankBuilder_ == null) { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; + } else { + return rerankBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public Builder setRerank(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank value) { + if (rerankBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + rerank_ = value; + } else { + rerankBuilder_.setMessage(value); + } + bitField0_ |= 0x01000000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public Builder setRerank( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder builderForValue) { + if (rerankBuilder_ == null) { + rerank_ = builderForValue.build(); + } else { + rerankBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x01000000; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public Builder mergeRerank(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank value) { + if (rerankBuilder_ == null) { + if (((bitField0_ & 0x01000000) != 0) && + rerank_ != null && + rerank_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance()) { + getRerankBuilder().mergeFrom(value); + } else { + rerank_ = value; + } + } else { + rerankBuilder_.mergeFrom(value); + } + if (rerank_ != null) { + bitField0_ |= 0x01000000; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public Builder clearRerank() { + bitField0_ = (bitField0_ & ~0x01000000); + rerank_ = null; + if (rerankBuilder_ != null) { + rerankBuilder_.dispose(); + rerankBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder getRerankBuilder() { + bitField0_ |= 0x01000000; + onChanged(); + return getRerankFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder getRerankOrBuilder() { + if (rerankBuilder_ != null) { + return rerankBuilder_.getMessageOrBuilder(); + } else { + return rerank_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance() : rerank_; + } + } + /** + * optional .weaviate.v1.Rerank rerank = 61; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder> + getRerankFieldBuilder() { + if (rerankBuilder_ == null) { + rerankBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder>( + getRerank(), + getParentForChildren(), + isClean()); + rerank_ = null; + } + return rerankBuilder_; + } + + private boolean uses123Api_ ; + /** + * bool uses_123_api = 100 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. + * See v1/search_get.proto;l=50 + * @return The uses123Api. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getUses123Api() { + return uses123Api_; + } + /** + * bool uses_123_api = 100 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. + * See v1/search_get.proto;l=50 + * @param value The uses123Api to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setUses123Api(boolean value) { + + uses123Api_ = value; + bitField0_ |= 0x02000000; + onChanged(); + return this; + } + /** + * bool uses_123_api = 100 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_123_api is deprecated. + * See v1/search_get.proto;l=50 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearUses123Api() { + bitField0_ = (bitField0_ & ~0x02000000); + uses123Api_ = false; + onChanged(); + return this; + } + + private boolean uses125Api_ ; + /** + * bool uses_125_api = 101 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. + * See v1/search_get.proto;l=51 + * @return The uses125Api. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getUses125Api() { + return uses125Api_; + } + /** + * bool uses_125_api = 101 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. + * See v1/search_get.proto;l=51 + * @param value The uses125Api to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setUses125Api(boolean value) { + + uses125Api_ = value; + bitField0_ |= 0x04000000; + onChanged(); + return this; + } + /** + * bool uses_125_api = 101 [deprecated = true]; + * @deprecated weaviate.v1.SearchRequest.uses_125_api is deprecated. + * See v1/search_get.proto;l=51 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearUses125Api() { + bitField0_ = (bitField0_ & ~0x04000000); + uses125Api_ = false; + onChanged(); + return this; + } + + private boolean uses127Api_ ; + /** + * bool uses_127_api = 102; + * @return The uses127Api. + */ + @java.lang.Override + public boolean getUses127Api() { + return uses127Api_; + } + /** + * bool uses_127_api = 102; + * @param value The uses127Api to set. + * @return This builder for chaining. + */ + public Builder setUses127Api(boolean value) { + + uses127Api_ = value; + bitField0_ |= 0x08000000; + onChanged(); + return this; + } + /** + * bool uses_127_api = 102; + * @return This builder for chaining. + */ + public Builder clearUses127Api() { + bitField0_ = (bitField0_ & ~0x08000000); + uses127Api_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.SearchRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SearchRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GroupByOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.GroupBy) + com.google.protobuf.MessageOrBuilder { + + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @return A list containing the path. + */ + java.util.List + getPathList(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @return The count of path. + */ + int getPathCount(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @param index The index of the element to return. + * @return The path at the given index. + */ + java.lang.String getPath(int index); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + com.google.protobuf.ByteString + getPathBytes(int index); + + /** + * int32 number_of_groups = 2; + * @return The numberOfGroups. + */ + int getNumberOfGroups(); + + /** + * int32 objects_per_group = 3; + * @return The objectsPerGroup. + */ + int getObjectsPerGroup(); + } + /** + * Protobuf type {@code weaviate.v1.GroupBy} + */ + public static final class GroupBy extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.GroupBy) + GroupByOrBuilder { + private static final long serialVersionUID = 0L; + // Use GroupBy.newBuilder() to construct. + private GroupBy(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GroupBy() { + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GroupBy(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder.class); + } + + public static final int PATH_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @return A list containing the path. + */ + public com.google.protobuf.ProtocolStringList + getPathList() { + return path_; + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @return The count of path. + */ + public int getPathCount() { + return path_.size(); + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @param index The index of the element to return. + * @return The path at the given index. + */ + public java.lang.String getPath(int index) { + return path_.get(index); + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But might
+     * be extended in the future.
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 1; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + public com.google.protobuf.ByteString + getPathBytes(int index) { + return path_.getByteString(index); + } + + public static final int NUMBER_OF_GROUPS_FIELD_NUMBER = 2; + private int numberOfGroups_ = 0; + /** + * int32 number_of_groups = 2; + * @return The numberOfGroups. + */ + @java.lang.Override + public int getNumberOfGroups() { + return numberOfGroups_; + } + + public static final int OBJECTS_PER_GROUP_FIELD_NUMBER = 3; + private int objectsPerGroup_ = 0; + /** + * int32 objects_per_group = 3; + * @return The objectsPerGroup. + */ + @java.lang.Override + public int getObjectsPerGroup() { + return objectsPerGroup_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < path_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, path_.getRaw(i)); + } + if (numberOfGroups_ != 0) { + output.writeInt32(2, numberOfGroups_); + } + if (objectsPerGroup_ != 0) { + output.writeInt32(3, objectsPerGroup_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < path_.size(); i++) { + dataSize += computeStringSizeNoTag(path_.getRaw(i)); + } + size += dataSize; + size += 1 * getPathList().size(); + } + if (numberOfGroups_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, numberOfGroups_); + } + if (objectsPerGroup_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, objectsPerGroup_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy) obj; + + if (!getPathList() + .equals(other.getPathList())) return false; + if (getNumberOfGroups() + != other.getNumberOfGroups()) return false; + if (getObjectsPerGroup() + != other.getObjectsPerGroup()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getPathCount() > 0) { + hash = (37 * hash) + PATH_FIELD_NUMBER; + hash = (53 * hash) + getPathList().hashCode(); + } + hash = (37 * hash) + NUMBER_OF_GROUPS_FIELD_NUMBER; + hash = (53 * hash) + getNumberOfGroups(); + hash = (37 * hash) + OBJECTS_PER_GROUP_FIELD_NUMBER; + hash = (53 * hash) + getObjectsPerGroup(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.GroupBy} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.GroupBy) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + numberOfGroups_ = 0; + objectsPerGroup_ = 0; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupBy_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + path_.makeImmutable(); + result.path_ = path_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.numberOfGroups_ = numberOfGroups_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.objectsPerGroup_ = objectsPerGroup_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy.getDefaultInstance()) return this; + if (!other.path_.isEmpty()) { + if (path_.isEmpty()) { + path_ = other.path_; + bitField0_ |= 0x00000001; + } else { + ensurePathIsMutable(); + path_.addAll(other.path_); + } + onChanged(); + } + if (other.getNumberOfGroups() != 0) { + setNumberOfGroups(other.getNumberOfGroups()); + } + if (other.getObjectsPerGroup() != 0) { + setObjectsPerGroup(other.getObjectsPerGroup()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensurePathIsMutable(); + path_.add(s); + break; + } // case 10 + case 16: { + numberOfGroups_ = input.readInt32(); + bitField0_ |= 0x00000002; + break; + } // case 16 + case 24: { + objectsPerGroup_ = input.readInt32(); + bitField0_ |= 0x00000004; + break; + } // case 24 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensurePathIsMutable() { + if (!path_.isModifiable()) { + path_ = new com.google.protobuf.LazyStringArrayList(path_); + } + bitField0_ |= 0x00000001; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @return A list containing the path. + */ + public com.google.protobuf.ProtocolStringList + getPathList() { + path_.makeImmutable(); + return path_; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @return The count of path. + */ + public int getPathCount() { + return path_.size(); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param index The index of the element to return. + * @return The path at the given index. + */ + public java.lang.String getPath(int index) { + return path_.get(index); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + public com.google.protobuf.ByteString + getPathBytes(int index) { + return path_.getByteString(index); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param index The index to set the value at. + * @param value The path to set. + * @return This builder for chaining. + */ + public Builder setPath( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePathIsMutable(); + path_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param value The path to add. + * @return This builder for chaining. + */ + public Builder addPath( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePathIsMutable(); + path_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param values The path to add. + * @return This builder for chaining. + */ + public Builder addAllPath( + java.lang.Iterable values) { + ensurePathIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, path_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @return This builder for chaining. + */ + public Builder clearPath() { + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But might
+       * be extended in the future.
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 1; + * @param value The bytes of the path to add. + * @return This builder for chaining. + */ + public Builder addPathBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensurePathIsMutable(); + path_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private int numberOfGroups_ ; + /** + * int32 number_of_groups = 2; + * @return The numberOfGroups. + */ + @java.lang.Override + public int getNumberOfGroups() { + return numberOfGroups_; + } + /** + * int32 number_of_groups = 2; + * @param value The numberOfGroups to set. + * @return This builder for chaining. + */ + public Builder setNumberOfGroups(int value) { + + numberOfGroups_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * int32 number_of_groups = 2; + * @return This builder for chaining. + */ + public Builder clearNumberOfGroups() { + bitField0_ = (bitField0_ & ~0x00000002); + numberOfGroups_ = 0; + onChanged(); + return this; + } + + private int objectsPerGroup_ ; + /** + * int32 objects_per_group = 3; + * @return The objectsPerGroup. + */ + @java.lang.Override + public int getObjectsPerGroup() { + return objectsPerGroup_; + } + /** + * int32 objects_per_group = 3; + * @param value The objectsPerGroup to set. + * @return This builder for chaining. + */ + public Builder setObjectsPerGroup(int value) { + + objectsPerGroup_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * int32 objects_per_group = 3; + * @return This builder for chaining. + */ + public Builder clearObjectsPerGroup() { + bitField0_ = (bitField0_ & ~0x00000004); + objectsPerGroup_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.GroupBy) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.GroupBy) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GroupBy parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupBy getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SortByOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.SortBy) + com.google.protobuf.MessageOrBuilder { + + /** + * bool ascending = 1; + * @return The ascending. + */ + boolean getAscending(); + + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @return A list containing the path. + */ + java.util.List + getPathList(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @return The count of path. + */ + int getPathCount(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @param index The index of the element to return. + * @return The path at the given index. + */ + java.lang.String getPath(int index); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + com.google.protobuf.ByteString + getPathBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.SortBy} + */ + public static final class SortBy extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.SortBy) + SortByOrBuilder { + private static final long serialVersionUID = 0L; + // Use SortBy.newBuilder() to construct. + private SortBy(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SortBy() { + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SortBy(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder.class); + } + + public static final int ASCENDING_FIELD_NUMBER = 1; + private boolean ascending_ = false; + /** + * bool ascending = 1; + * @return The ascending. + */ + @java.lang.Override + public boolean getAscending() { + return ascending_; + } + + public static final int PATH_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @return A list containing the path. + */ + public com.google.protobuf.ProtocolStringList + getPathList() { + return path_; + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @return The count of path. + */ + public int getPathCount() { + return path_.size(); + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @param index The index of the element to return. + * @return The path at the given index. + */ + public java.lang.String getPath(int index) { + return path_.get(index); + } + /** + *
+     * currently only supports one entry (eg just properties, no refs). But the
+     * weaviate datastructure already has paths in it and this makes it easily
+     * extendable in the future
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated string path = 2; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + public com.google.protobuf.ByteString + getPathBytes(int index) { + return path_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (ascending_ != false) { + output.writeBool(1, ascending_); + } + for (int i = 0; i < path_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, path_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (ascending_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(1, ascending_); + } + { + int dataSize = 0; + for (int i = 0; i < path_.size(); i++) { + dataSize += computeStringSizeNoTag(path_.getRaw(i)); + } + size += dataSize; + size += 1 * getPathList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy) obj; + + if (getAscending() + != other.getAscending()) return false; + if (!getPathList() + .equals(other.getPathList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + ASCENDING_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getAscending()); + if (getPathCount() > 0) { + hash = (37 * hash) + PATH_FIELD_NUMBER; + hash = (53 * hash) + getPathList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.SortBy} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.SortBy) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortByOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + ascending_ = false; + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SortBy_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.ascending_ = ascending_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + path_.makeImmutable(); + result.path_ = path_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy.getDefaultInstance()) return this; + if (other.getAscending() != false) { + setAscending(other.getAscending()); + } + if (!other.path_.isEmpty()) { + if (path_.isEmpty()) { + path_ = other.path_; + bitField0_ |= 0x00000002; + } else { + ensurePathIsMutable(); + path_.addAll(other.path_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + ascending_ = input.readBool(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + ensurePathIsMutable(); + path_.add(s); + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private boolean ascending_ ; + /** + * bool ascending = 1; + * @return The ascending. + */ + @java.lang.Override + public boolean getAscending() { + return ascending_; + } + /** + * bool ascending = 1; + * @param value The ascending to set. + * @return This builder for chaining. + */ + public Builder setAscending(boolean value) { + + ascending_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * bool ascending = 1; + * @return This builder for chaining. + */ + public Builder clearAscending() { + bitField0_ = (bitField0_ & ~0x00000001); + ascending_ = false; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringArrayList path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensurePathIsMutable() { + if (!path_.isModifiable()) { + path_ = new com.google.protobuf.LazyStringArrayList(path_); + } + bitField0_ |= 0x00000002; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @return A list containing the path. + */ + public com.google.protobuf.ProtocolStringList + getPathList() { + path_.makeImmutable(); + return path_; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @return The count of path. + */ + public int getPathCount() { + return path_.size(); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param index The index of the element to return. + * @return The path at the given index. + */ + public java.lang.String getPath(int index) { + return path_.get(index); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param index The index of the value to return. + * @return The bytes of the path at the given index. + */ + public com.google.protobuf.ByteString + getPathBytes(int index) { + return path_.getByteString(index); + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param index The index to set the value at. + * @param value The path to set. + * @return This builder for chaining. + */ + public Builder setPath( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePathIsMutable(); + path_.set(index, value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param value The path to add. + * @return This builder for chaining. + */ + public Builder addPath( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePathIsMutable(); + path_.add(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param values The path to add. + * @return This builder for chaining. + */ + public Builder addAllPath( + java.lang.Iterable values) { + ensurePathIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, path_); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @return This builder for chaining. + */ + public Builder clearPath() { + path_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002);; + onChanged(); + return this; + } + /** + *
+       * currently only supports one entry (eg just properties, no refs). But the
+       * weaviate datastructure already has paths in it and this makes it easily
+       * extendable in the future
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated string path = 2; + * @param value The bytes of the path to add. + * @return This builder for chaining. + */ + public Builder addPathBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensurePathIsMutable(); + path_.add(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.SortBy) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.SortBy) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SortBy parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SortBy getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface MetadataRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.MetadataRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * bool uuid = 1; + * @return The uuid. + */ + boolean getUuid(); + + /** + * bool vector = 2; + * @return The vector. + */ + boolean getVector(); + + /** + * bool creation_time_unix = 3; + * @return The creationTimeUnix. + */ + boolean getCreationTimeUnix(); + + /** + * bool last_update_time_unix = 4; + * @return The lastUpdateTimeUnix. + */ + boolean getLastUpdateTimeUnix(); + + /** + * bool distance = 5; + * @return The distance. + */ + boolean getDistance(); + + /** + * bool certainty = 6; + * @return The certainty. + */ + boolean getCertainty(); + + /** + * bool score = 7; + * @return The score. + */ + boolean getScore(); + + /** + * bool explain_score = 8; + * @return The explainScore. + */ + boolean getExplainScore(); + + /** + * bool is_consistent = 9; + * @return The isConsistent. + */ + boolean getIsConsistent(); + + /** + * repeated string vectors = 10; + * @return A list containing the vectors. + */ + java.util.List + getVectorsList(); + /** + * repeated string vectors = 10; + * @return The count of vectors. + */ + int getVectorsCount(); + /** + * repeated string vectors = 10; + * @param index The index of the element to return. + * @return The vectors at the given index. + */ + java.lang.String getVectors(int index); + /** + * repeated string vectors = 10; + * @param index The index of the value to return. + * @return The bytes of the vectors at the given index. + */ + com.google.protobuf.ByteString + getVectorsBytes(int index); + } + /** + * Protobuf type {@code weaviate.v1.MetadataRequest} + */ + public static final class MetadataRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.MetadataRequest) + MetadataRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use MetadataRequest.newBuilder() to construct. + private MetadataRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private MetadataRequest() { + vectors_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new MetadataRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder.class); + } + + public static final int UUID_FIELD_NUMBER = 1; + private boolean uuid_ = false; + /** + * bool uuid = 1; + * @return The uuid. + */ + @java.lang.Override + public boolean getUuid() { + return uuid_; + } + + public static final int VECTOR_FIELD_NUMBER = 2; + private boolean vector_ = false; + /** + * bool vector = 2; + * @return The vector. + */ + @java.lang.Override + public boolean getVector() { + return vector_; + } + + public static final int CREATION_TIME_UNIX_FIELD_NUMBER = 3; + private boolean creationTimeUnix_ = false; + /** + * bool creation_time_unix = 3; + * @return The creationTimeUnix. + */ + @java.lang.Override + public boolean getCreationTimeUnix() { + return creationTimeUnix_; + } + + public static final int LAST_UPDATE_TIME_UNIX_FIELD_NUMBER = 4; + private boolean lastUpdateTimeUnix_ = false; + /** + * bool last_update_time_unix = 4; + * @return The lastUpdateTimeUnix. + */ + @java.lang.Override + public boolean getLastUpdateTimeUnix() { + return lastUpdateTimeUnix_; + } + + public static final int DISTANCE_FIELD_NUMBER = 5; + private boolean distance_ = false; + /** + * bool distance = 5; + * @return The distance. + */ + @java.lang.Override + public boolean getDistance() { + return distance_; + } + + public static final int CERTAINTY_FIELD_NUMBER = 6; + private boolean certainty_ = false; + /** + * bool certainty = 6; + * @return The certainty. + */ + @java.lang.Override + public boolean getCertainty() { + return certainty_; + } + + public static final int SCORE_FIELD_NUMBER = 7; + private boolean score_ = false; + /** + * bool score = 7; + * @return The score. + */ + @java.lang.Override + public boolean getScore() { + return score_; + } + + public static final int EXPLAIN_SCORE_FIELD_NUMBER = 8; + private boolean explainScore_ = false; + /** + * bool explain_score = 8; + * @return The explainScore. + */ + @java.lang.Override + public boolean getExplainScore() { + return explainScore_; + } + + public static final int IS_CONSISTENT_FIELD_NUMBER = 9; + private boolean isConsistent_ = false; + /** + * bool is_consistent = 9; + * @return The isConsistent. + */ + @java.lang.Override + public boolean getIsConsistent() { + return isConsistent_; + } + + public static final int VECTORS_FIELD_NUMBER = 10; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList vectors_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string vectors = 10; + * @return A list containing the vectors. + */ + public com.google.protobuf.ProtocolStringList + getVectorsList() { + return vectors_; + } + /** + * repeated string vectors = 10; + * @return The count of vectors. + */ + public int getVectorsCount() { + return vectors_.size(); + } + /** + * repeated string vectors = 10; + * @param index The index of the element to return. + * @return The vectors at the given index. + */ + public java.lang.String getVectors(int index) { + return vectors_.get(index); + } + /** + * repeated string vectors = 10; + * @param index The index of the value to return. + * @return The bytes of the vectors at the given index. + */ + public com.google.protobuf.ByteString + getVectorsBytes(int index) { + return vectors_.getByteString(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (uuid_ != false) { + output.writeBool(1, uuid_); + } + if (vector_ != false) { + output.writeBool(2, vector_); + } + if (creationTimeUnix_ != false) { + output.writeBool(3, creationTimeUnix_); + } + if (lastUpdateTimeUnix_ != false) { + output.writeBool(4, lastUpdateTimeUnix_); + } + if (distance_ != false) { + output.writeBool(5, distance_); + } + if (certainty_ != false) { + output.writeBool(6, certainty_); + } + if (score_ != false) { + output.writeBool(7, score_); + } + if (explainScore_ != false) { + output.writeBool(8, explainScore_); + } + if (isConsistent_ != false) { + output.writeBool(9, isConsistent_); + } + for (int i = 0; i < vectors_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 10, vectors_.getRaw(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (uuid_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(1, uuid_); + } + if (vector_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(2, vector_); + } + if (creationTimeUnix_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, creationTimeUnix_); + } + if (lastUpdateTimeUnix_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(4, lastUpdateTimeUnix_); + } + if (distance_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(5, distance_); + } + if (certainty_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(6, certainty_); + } + if (score_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(7, score_); + } + if (explainScore_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(8, explainScore_); + } + if (isConsistent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(9, isConsistent_); + } + { + int dataSize = 0; + for (int i = 0; i < vectors_.size(); i++) { + dataSize += computeStringSizeNoTag(vectors_.getRaw(i)); + } + size += dataSize; + size += 1 * getVectorsList().size(); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest) obj; + + if (getUuid() + != other.getUuid()) return false; + if (getVector() + != other.getVector()) return false; + if (getCreationTimeUnix() + != other.getCreationTimeUnix()) return false; + if (getLastUpdateTimeUnix() + != other.getLastUpdateTimeUnix()) return false; + if (getDistance() + != other.getDistance()) return false; + if (getCertainty() + != other.getCertainty()) return false; + if (getScore() + != other.getScore()) return false; + if (getExplainScore() + != other.getExplainScore()) return false; + if (getIsConsistent() + != other.getIsConsistent()) return false; + if (!getVectorsList() + .equals(other.getVectorsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + UUID_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getUuid()); + hash = (37 * hash) + VECTOR_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getVector()); + hash = (37 * hash) + CREATION_TIME_UNIX_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCreationTimeUnix()); + hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getLastUpdateTimeUnix()); + hash = (37 * hash) + DISTANCE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getDistance()); + hash = (37 * hash) + CERTAINTY_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCertainty()); + hash = (37 * hash) + SCORE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getScore()); + hash = (37 * hash) + EXPLAIN_SCORE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getExplainScore()); + hash = (37 * hash) + IS_CONSISTENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsConsistent()); + if (getVectorsCount() > 0) { + hash = (37 * hash) + VECTORS_FIELD_NUMBER; + hash = (53 * hash) + getVectorsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.MetadataRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.MetadataRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + uuid_ = false; + vector_ = false; + creationTimeUnix_ = false; + lastUpdateTimeUnix_ = false; + distance_ = false; + certainty_ = false; + score_ = false; + explainScore_ = false; + isConsistent_ = false; + vectors_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.uuid_ = uuid_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.vector_ = vector_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.creationTimeUnix_ = creationTimeUnix_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.lastUpdateTimeUnix_ = lastUpdateTimeUnix_; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.distance_ = distance_; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.certainty_ = certainty_; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.score_ = score_; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + result.explainScore_ = explainScore_; + } + if (((from_bitField0_ & 0x00000100) != 0)) { + result.isConsistent_ = isConsistent_; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + vectors_.makeImmutable(); + result.vectors_ = vectors_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) return this; + if (other.getUuid() != false) { + setUuid(other.getUuid()); + } + if (other.getVector() != false) { + setVector(other.getVector()); + } + if (other.getCreationTimeUnix() != false) { + setCreationTimeUnix(other.getCreationTimeUnix()); + } + if (other.getLastUpdateTimeUnix() != false) { + setLastUpdateTimeUnix(other.getLastUpdateTimeUnix()); + } + if (other.getDistance() != false) { + setDistance(other.getDistance()); + } + if (other.getCertainty() != false) { + setCertainty(other.getCertainty()); + } + if (other.getScore() != false) { + setScore(other.getScore()); + } + if (other.getExplainScore() != false) { + setExplainScore(other.getExplainScore()); + } + if (other.getIsConsistent() != false) { + setIsConsistent(other.getIsConsistent()); + } + if (!other.vectors_.isEmpty()) { + if (vectors_.isEmpty()) { + vectors_ = other.vectors_; + bitField0_ |= 0x00000200; + } else { + ensureVectorsIsMutable(); + vectors_.addAll(other.vectors_); + } + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + uuid_ = input.readBool(); + bitField0_ |= 0x00000001; + break; + } // case 8 + case 16: { + vector_ = input.readBool(); + bitField0_ |= 0x00000002; + break; + } // case 16 + case 24: { + creationTimeUnix_ = input.readBool(); + bitField0_ |= 0x00000004; + break; + } // case 24 + case 32: { + lastUpdateTimeUnix_ = input.readBool(); + bitField0_ |= 0x00000008; + break; + } // case 32 + case 40: { + distance_ = input.readBool(); + bitField0_ |= 0x00000010; + break; + } // case 40 + case 48: { + certainty_ = input.readBool(); + bitField0_ |= 0x00000020; + break; + } // case 48 + case 56: { + score_ = input.readBool(); + bitField0_ |= 0x00000040; + break; + } // case 56 + case 64: { + explainScore_ = input.readBool(); + bitField0_ |= 0x00000080; + break; + } // case 64 + case 72: { + isConsistent_ = input.readBool(); + bitField0_ |= 0x00000100; + break; + } // case 72 + case 82: { + java.lang.String s = input.readStringRequireUtf8(); + ensureVectorsIsMutable(); + vectors_.add(s); + break; + } // case 82 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private boolean uuid_ ; + /** + * bool uuid = 1; + * @return The uuid. + */ + @java.lang.Override + public boolean getUuid() { + return uuid_; + } + /** + * bool uuid = 1; + * @param value The uuid to set. + * @return This builder for chaining. + */ + public Builder setUuid(boolean value) { + + uuid_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * bool uuid = 1; + * @return This builder for chaining. + */ + public Builder clearUuid() { + bitField0_ = (bitField0_ & ~0x00000001); + uuid_ = false; + onChanged(); + return this; + } + + private boolean vector_ ; + /** + * bool vector = 2; + * @return The vector. + */ + @java.lang.Override + public boolean getVector() { + return vector_; + } + /** + * bool vector = 2; + * @param value The vector to set. + * @return This builder for chaining. + */ + public Builder setVector(boolean value) { + + vector_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * bool vector = 2; + * @return This builder for chaining. + */ + public Builder clearVector() { + bitField0_ = (bitField0_ & ~0x00000002); + vector_ = false; + onChanged(); + return this; + } + + private boolean creationTimeUnix_ ; + /** + * bool creation_time_unix = 3; + * @return The creationTimeUnix. + */ + @java.lang.Override + public boolean getCreationTimeUnix() { + return creationTimeUnix_; + } + /** + * bool creation_time_unix = 3; + * @param value The creationTimeUnix to set. + * @return This builder for chaining. + */ + public Builder setCreationTimeUnix(boolean value) { + + creationTimeUnix_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * bool creation_time_unix = 3; + * @return This builder for chaining. + */ + public Builder clearCreationTimeUnix() { + bitField0_ = (bitField0_ & ~0x00000004); + creationTimeUnix_ = false; + onChanged(); + return this; + } + + private boolean lastUpdateTimeUnix_ ; + /** + * bool last_update_time_unix = 4; + * @return The lastUpdateTimeUnix. + */ + @java.lang.Override + public boolean getLastUpdateTimeUnix() { + return lastUpdateTimeUnix_; + } + /** + * bool last_update_time_unix = 4; + * @param value The lastUpdateTimeUnix to set. + * @return This builder for chaining. + */ + public Builder setLastUpdateTimeUnix(boolean value) { + + lastUpdateTimeUnix_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * bool last_update_time_unix = 4; + * @return This builder for chaining. + */ + public Builder clearLastUpdateTimeUnix() { + bitField0_ = (bitField0_ & ~0x00000008); + lastUpdateTimeUnix_ = false; + onChanged(); + return this; + } + + private boolean distance_ ; + /** + * bool distance = 5; + * @return The distance. + */ + @java.lang.Override + public boolean getDistance() { + return distance_; + } + /** + * bool distance = 5; + * @param value The distance to set. + * @return This builder for chaining. + */ + public Builder setDistance(boolean value) { + + distance_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * bool distance = 5; + * @return This builder for chaining. + */ + public Builder clearDistance() { + bitField0_ = (bitField0_ & ~0x00000010); + distance_ = false; + onChanged(); + return this; + } + + private boolean certainty_ ; + /** + * bool certainty = 6; + * @return The certainty. + */ + @java.lang.Override + public boolean getCertainty() { + return certainty_; + } + /** + * bool certainty = 6; + * @param value The certainty to set. + * @return This builder for chaining. + */ + public Builder setCertainty(boolean value) { + + certainty_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * bool certainty = 6; + * @return This builder for chaining. + */ + public Builder clearCertainty() { + bitField0_ = (bitField0_ & ~0x00000020); + certainty_ = false; + onChanged(); + return this; + } + + private boolean score_ ; + /** + * bool score = 7; + * @return The score. + */ + @java.lang.Override + public boolean getScore() { + return score_; + } + /** + * bool score = 7; + * @param value The score to set. + * @return This builder for chaining. + */ + public Builder setScore(boolean value) { + + score_ = value; + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + * bool score = 7; + * @return This builder for chaining. + */ + public Builder clearScore() { + bitField0_ = (bitField0_ & ~0x00000040); + score_ = false; + onChanged(); + return this; + } + + private boolean explainScore_ ; + /** + * bool explain_score = 8; + * @return The explainScore. + */ + @java.lang.Override + public boolean getExplainScore() { + return explainScore_; + } + /** + * bool explain_score = 8; + * @param value The explainScore to set. + * @return This builder for chaining. + */ + public Builder setExplainScore(boolean value) { + + explainScore_ = value; + bitField0_ |= 0x00000080; + onChanged(); + return this; + } + /** + * bool explain_score = 8; + * @return This builder for chaining. + */ + public Builder clearExplainScore() { + bitField0_ = (bitField0_ & ~0x00000080); + explainScore_ = false; + onChanged(); + return this; + } + + private boolean isConsistent_ ; + /** + * bool is_consistent = 9; + * @return The isConsistent. + */ + @java.lang.Override + public boolean getIsConsistent() { + return isConsistent_; + } + /** + * bool is_consistent = 9; + * @param value The isConsistent to set. + * @return This builder for chaining. + */ + public Builder setIsConsistent(boolean value) { + + isConsistent_ = value; + bitField0_ |= 0x00000100; + onChanged(); + return this; + } + /** + * bool is_consistent = 9; + * @return This builder for chaining. + */ + public Builder clearIsConsistent() { + bitField0_ = (bitField0_ & ~0x00000100); + isConsistent_ = false; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringArrayList vectors_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureVectorsIsMutable() { + if (!vectors_.isModifiable()) { + vectors_ = new com.google.protobuf.LazyStringArrayList(vectors_); + } + bitField0_ |= 0x00000200; + } + /** + * repeated string vectors = 10; + * @return A list containing the vectors. + */ + public com.google.protobuf.ProtocolStringList + getVectorsList() { + vectors_.makeImmutable(); + return vectors_; + } + /** + * repeated string vectors = 10; + * @return The count of vectors. + */ + public int getVectorsCount() { + return vectors_.size(); + } + /** + * repeated string vectors = 10; + * @param index The index of the element to return. + * @return The vectors at the given index. + */ + public java.lang.String getVectors(int index) { + return vectors_.get(index); + } + /** + * repeated string vectors = 10; + * @param index The index of the value to return. + * @return The bytes of the vectors at the given index. + */ + public com.google.protobuf.ByteString + getVectorsBytes(int index) { + return vectors_.getByteString(index); + } + /** + * repeated string vectors = 10; + * @param index The index to set the value at. + * @param value The vectors to set. + * @return This builder for chaining. + */ + public Builder setVectors( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureVectorsIsMutable(); + vectors_.set(index, value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + * repeated string vectors = 10; + * @param value The vectors to add. + * @return This builder for chaining. + */ + public Builder addVectors( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureVectorsIsMutable(); + vectors_.add(value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + * repeated string vectors = 10; + * @param values The vectors to add. + * @return This builder for chaining. + */ + public Builder addAllVectors( + java.lang.Iterable values) { + ensureVectorsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, vectors_); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + * repeated string vectors = 10; + * @return This builder for chaining. + */ + public Builder clearVectors() { + vectors_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200);; + onChanged(); + return this; + } + /** + * repeated string vectors = 10; + * @param value The bytes of the vectors to add. + * @return This builder for chaining. + */ + public Builder addVectorsBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureVectorsIsMutable(); + vectors_.add(value); + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.MetadataRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.MetadataRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public MetadataRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface PropertiesRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.PropertiesRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated string non_ref_properties = 1; + * @return A list containing the nonRefProperties. + */ + java.util.List + getNonRefPropertiesList(); + /** + * repeated string non_ref_properties = 1; + * @return The count of nonRefProperties. + */ + int getNonRefPropertiesCount(); + /** + * repeated string non_ref_properties = 1; + * @param index The index of the element to return. + * @return The nonRefProperties at the given index. + */ + java.lang.String getNonRefProperties(int index); + /** + * repeated string non_ref_properties = 1; + * @param index The index of the value to return. + * @return The bytes of the nonRefProperties at the given index. + */ + com.google.protobuf.ByteString + getNonRefPropertiesBytes(int index); + + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + java.util.List + getRefPropertiesList(); + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index); + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + int getRefPropertiesCount(); + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + java.util.List + getRefPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( + int index); + + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + java.util.List + getObjectPropertiesList(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + int getObjectPropertiesCount(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + java.util.List + getObjectPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index); + + /** + * bool return_all_nonref_properties = 11; + * @return The returnAllNonrefProperties. + */ + boolean getReturnAllNonrefProperties(); + } + /** + * Protobuf type {@code weaviate.v1.PropertiesRequest} + */ + public static final class PropertiesRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.PropertiesRequest) + PropertiesRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use PropertiesRequest.newBuilder() to construct. + private PropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private PropertiesRequest() { + nonRefProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + refProperties_ = java.util.Collections.emptyList(); + objectProperties_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new PropertiesRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder.class); + } + + public static final int NON_REF_PROPERTIES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList nonRefProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string non_ref_properties = 1; + * @return A list containing the nonRefProperties. + */ + public com.google.protobuf.ProtocolStringList + getNonRefPropertiesList() { + return nonRefProperties_; + } + /** + * repeated string non_ref_properties = 1; + * @return The count of nonRefProperties. + */ + public int getNonRefPropertiesCount() { + return nonRefProperties_.size(); + } + /** + * repeated string non_ref_properties = 1; + * @param index The index of the element to return. + * @return The nonRefProperties at the given index. + */ + public java.lang.String getNonRefProperties(int index) { + return nonRefProperties_.get(index); + } + /** + * repeated string non_ref_properties = 1; + * @param index The index of the value to return. + * @return The bytes of the nonRefProperties at the given index. + */ + public com.google.protobuf.ByteString + getNonRefPropertiesBytes(int index) { + return nonRefProperties_.getByteString(index); + } + + public static final int REF_PROPERTIES_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List refProperties_; + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + @java.lang.Override + public java.util.List getRefPropertiesList() { + return refProperties_; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + @java.lang.Override + public java.util.List + getRefPropertiesOrBuilderList() { + return refProperties_; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + @java.lang.Override + public int getRefPropertiesCount() { + return refProperties_.size(); + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index) { + return refProperties_.get(index); + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( + int index) { + return refProperties_.get(index); + } + + public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private java.util.List objectProperties_; + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public java.util.List getObjectPropertiesList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public java.util.List + getObjectPropertiesOrBuilderList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public int getObjectPropertiesCount() { + return objectProperties_.size(); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { + return objectProperties_.get(index); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index) { + return objectProperties_.get(index); + } + + public static final int RETURN_ALL_NONREF_PROPERTIES_FIELD_NUMBER = 11; + private boolean returnAllNonrefProperties_ = false; + /** + * bool return_all_nonref_properties = 11; + * @return The returnAllNonrefProperties. + */ + @java.lang.Override + public boolean getReturnAllNonrefProperties() { + return returnAllNonrefProperties_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < nonRefProperties_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, nonRefProperties_.getRaw(i)); + } + for (int i = 0; i < refProperties_.size(); i++) { + output.writeMessage(2, refProperties_.get(i)); + } + for (int i = 0; i < objectProperties_.size(); i++) { + output.writeMessage(3, objectProperties_.get(i)); + } + if (returnAllNonrefProperties_ != false) { + output.writeBool(11, returnAllNonrefProperties_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < nonRefProperties_.size(); i++) { + dataSize += computeStringSizeNoTag(nonRefProperties_.getRaw(i)); + } + size += dataSize; + size += 1 * getNonRefPropertiesList().size(); + } + for (int i = 0; i < refProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, refProperties_.get(i)); + } + for (int i = 0; i < objectProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, objectProperties_.get(i)); + } + if (returnAllNonrefProperties_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(11, returnAllNonrefProperties_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest) obj; + + if (!getNonRefPropertiesList() + .equals(other.getNonRefPropertiesList())) return false; + if (!getRefPropertiesList() + .equals(other.getRefPropertiesList())) return false; + if (!getObjectPropertiesList() + .equals(other.getObjectPropertiesList())) return false; + if (getReturnAllNonrefProperties() + != other.getReturnAllNonrefProperties()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getNonRefPropertiesCount() > 0) { + hash = (37 * hash) + NON_REF_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getNonRefPropertiesList().hashCode(); + } + if (getRefPropertiesCount() > 0) { + hash = (37 * hash) + REF_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getRefPropertiesList().hashCode(); + } + if (getObjectPropertiesCount() > 0) { + hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getObjectPropertiesList().hashCode(); + } + hash = (37 * hash) + RETURN_ALL_NONREF_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getReturnAllNonrefProperties()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.PropertiesRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.PropertiesRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + nonRefProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + if (refPropertiesBuilder_ == null) { + refProperties_ = java.util.Collections.emptyList(); + } else { + refProperties_ = null; + refPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + } else { + objectProperties_ = null; + objectPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + returnAllNonrefProperties_ = false; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest result) { + if (refPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + refProperties_ = java.util.Collections.unmodifiableList(refProperties_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.refProperties_ = refProperties_; + } else { + result.refProperties_ = refPropertiesBuilder_.build(); + } + if (objectPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.objectProperties_ = objectProperties_; + } else { + result.objectProperties_ = objectPropertiesBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + nonRefProperties_.makeImmutable(); + result.nonRefProperties_ = nonRefProperties_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.returnAllNonrefProperties_ = returnAllNonrefProperties_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) return this; + if (!other.nonRefProperties_.isEmpty()) { + if (nonRefProperties_.isEmpty()) { + nonRefProperties_ = other.nonRefProperties_; + bitField0_ |= 0x00000001; + } else { + ensureNonRefPropertiesIsMutable(); + nonRefProperties_.addAll(other.nonRefProperties_); + } + onChanged(); + } + if (refPropertiesBuilder_ == null) { + if (!other.refProperties_.isEmpty()) { + if (refProperties_.isEmpty()) { + refProperties_ = other.refProperties_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureRefPropertiesIsMutable(); + refProperties_.addAll(other.refProperties_); + } + onChanged(); + } + } else { + if (!other.refProperties_.isEmpty()) { + if (refPropertiesBuilder_.isEmpty()) { + refPropertiesBuilder_.dispose(); + refPropertiesBuilder_ = null; + refProperties_ = other.refProperties_; + bitField0_ = (bitField0_ & ~0x00000002); + refPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getRefPropertiesFieldBuilder() : null; + } else { + refPropertiesBuilder_.addAllMessages(other.refProperties_); + } + } + } + if (objectPropertiesBuilder_ == null) { + if (!other.objectProperties_.isEmpty()) { + if (objectProperties_.isEmpty()) { + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureObjectPropertiesIsMutable(); + objectProperties_.addAll(other.objectProperties_); + } + onChanged(); + } + } else { + if (!other.objectProperties_.isEmpty()) { + if (objectPropertiesBuilder_.isEmpty()) { + objectPropertiesBuilder_.dispose(); + objectPropertiesBuilder_ = null; + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000004); + objectPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getObjectPropertiesFieldBuilder() : null; + } else { + objectPropertiesBuilder_.addAllMessages(other.objectProperties_); + } + } + } + if (other.getReturnAllNonrefProperties() != false) { + setReturnAllNonrefProperties(other.getReturnAllNonrefProperties()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + ensureNonRefPropertiesIsMutable(); + nonRefProperties_.add(s); + break; + } // case 10 + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.parser(), + extensionRegistry); + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + refProperties_.add(m); + } else { + refPropertiesBuilder_.addMessage(m); + } + break; + } // case 18 + case 26: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.parser(), + extensionRegistry); + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(m); + } else { + objectPropertiesBuilder_.addMessage(m); + } + break; + } // case 26 + case 88: { + returnAllNonrefProperties_ = input.readBool(); + bitField0_ |= 0x00000008; + break; + } // case 88 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private com.google.protobuf.LazyStringArrayList nonRefProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensureNonRefPropertiesIsMutable() { + if (!nonRefProperties_.isModifiable()) { + nonRefProperties_ = new com.google.protobuf.LazyStringArrayList(nonRefProperties_); + } + bitField0_ |= 0x00000001; + } + /** + * repeated string non_ref_properties = 1; + * @return A list containing the nonRefProperties. + */ + public com.google.protobuf.ProtocolStringList + getNonRefPropertiesList() { + nonRefProperties_.makeImmutable(); + return nonRefProperties_; + } + /** + * repeated string non_ref_properties = 1; + * @return The count of nonRefProperties. + */ + public int getNonRefPropertiesCount() { + return nonRefProperties_.size(); + } + /** + * repeated string non_ref_properties = 1; + * @param index The index of the element to return. + * @return The nonRefProperties at the given index. + */ + public java.lang.String getNonRefProperties(int index) { + return nonRefProperties_.get(index); + } + /** + * repeated string non_ref_properties = 1; + * @param index The index of the value to return. + * @return The bytes of the nonRefProperties at the given index. + */ + public com.google.protobuf.ByteString + getNonRefPropertiesBytes(int index) { + return nonRefProperties_.getByteString(index); + } + /** + * repeated string non_ref_properties = 1; + * @param index The index to set the value at. + * @param value The nonRefProperties to set. + * @return This builder for chaining. + */ + public Builder setNonRefProperties( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureNonRefPropertiesIsMutable(); + nonRefProperties_.set(index, value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string non_ref_properties = 1; + * @param value The nonRefProperties to add. + * @return This builder for chaining. + */ + public Builder addNonRefProperties( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensureNonRefPropertiesIsMutable(); + nonRefProperties_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string non_ref_properties = 1; + * @param values The nonRefProperties to add. + * @return This builder for chaining. + */ + public Builder addAllNonRefProperties( + java.lang.Iterable values) { + ensureNonRefPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, nonRefProperties_); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * repeated string non_ref_properties = 1; + * @return This builder for chaining. + */ + public Builder clearNonRefProperties() { + nonRefProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001);; + onChanged(); + return this; + } + /** + * repeated string non_ref_properties = 1; + * @param value The bytes of the nonRefProperties to add. + * @return This builder for chaining. + */ + public Builder addNonRefPropertiesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensureNonRefPropertiesIsMutable(); + nonRefProperties_.add(value); + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.util.List refProperties_ = + java.util.Collections.emptyList(); + private void ensureRefPropertiesIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + refProperties_ = new java.util.ArrayList(refProperties_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder> refPropertiesBuilder_; + + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public java.util.List getRefPropertiesList() { + if (refPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(refProperties_); + } else { + return refPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public int getRefPropertiesCount() { + if (refPropertiesBuilder_ == null) { + return refProperties_.size(); + } else { + return refPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getRefProperties(int index) { + if (refPropertiesBuilder_ == null) { + return refProperties_.get(index); + } else { + return refPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder setRefProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest value) { + if (refPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropertiesIsMutable(); + refProperties_.set(index, value); + onChanged(); + } else { + refPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder setRefProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + refProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + refPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder addRefProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest value) { + if (refPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropertiesIsMutable(); + refProperties_.add(value); + onChanged(); + } else { + refPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder addRefProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest value) { + if (refPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropertiesIsMutable(); + refProperties_.add(index, value); + onChanged(); + } else { + refPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder addRefProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + refProperties_.add(builderForValue.build()); + onChanged(); + } else { + refPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder addRefProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder builderForValue) { + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + refProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + refPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder addAllRefProperties( + java.lang.Iterable values) { + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, refProperties_); + onChanged(); + } else { + refPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder clearRefProperties() { + if (refPropertiesBuilder_ == null) { + refProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + refPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public Builder removeRefProperties(int index) { + if (refPropertiesBuilder_ == null) { + ensureRefPropertiesIsMutable(); + refProperties_.remove(index); + onChanged(); + } else { + refPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder getRefPropertiesBuilder( + int index) { + return getRefPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder getRefPropertiesOrBuilder( + int index) { + if (refPropertiesBuilder_ == null) { + return refProperties_.get(index); } else { + return refPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public java.util.List + getRefPropertiesOrBuilderList() { + if (refPropertiesBuilder_ != null) { + return refPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(refProperties_); + } + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder addRefPropertiesBuilder() { + return getRefPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder addRefPropertiesBuilder( + int index) { + return getRefPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.RefPropertiesRequest ref_properties = 2; + */ + public java.util.List + getRefPropertiesBuilderList() { + return getRefPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder> + getRefPropertiesFieldBuilder() { + if (refPropertiesBuilder_ == null) { + refPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder>( + refProperties_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + refProperties_ = null; + } + return refPropertiesBuilder_; + } + + private java.util.List objectProperties_ = + java.util.Collections.emptyList(); + private void ensureObjectPropertiesIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + objectProperties_ = new java.util.ArrayList(objectProperties_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> objectPropertiesBuilder_; + + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List getObjectPropertiesList() { + if (objectPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(objectProperties_); + } else { + return objectPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public int getObjectPropertiesCount() { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.size(); + } else { + return objectPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); + } else { + return objectPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addAllObjectProperties( + java.lang.Iterable values) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, objectProperties_); + onChanged(); + } else { + objectPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder clearObjectProperties() { + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + objectPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder removeObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.remove(index); + onChanged(); + } else { + objectPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder getObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); } else { + return objectPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List + getObjectPropertiesOrBuilderList() { + if (objectPropertiesBuilder_ != null) { + return objectPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(objectProperties_); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder() { + return getObjectPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List + getObjectPropertiesBuilderList() { + return getObjectPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> + getObjectPropertiesFieldBuilder() { + if (objectPropertiesBuilder_ == null) { + objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder>( + objectProperties_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + objectProperties_ = null; + } + return objectPropertiesBuilder_; + } + + private boolean returnAllNonrefProperties_ ; + /** + * bool return_all_nonref_properties = 11; + * @return The returnAllNonrefProperties. + */ + @java.lang.Override + public boolean getReturnAllNonrefProperties() { + return returnAllNonrefProperties_; + } + /** + * bool return_all_nonref_properties = 11; + * @param value The returnAllNonrefProperties to set. + * @return This builder for chaining. + */ + public Builder setReturnAllNonrefProperties(boolean value) { + + returnAllNonrefProperties_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * bool return_all_nonref_properties = 11; + * @return This builder for chaining. + */ + public Builder clearReturnAllNonrefProperties() { + bitField0_ = (bitField0_ & ~0x00000008); + returnAllNonrefProperties_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.PropertiesRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.PropertiesRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public PropertiesRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ObjectPropertiesRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.ObjectPropertiesRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string prop_name = 1; + * @return The propName. + */ + java.lang.String getPropName(); + /** + * string prop_name = 1; + * @return The bytes for propName. + */ + com.google.protobuf.ByteString + getPropNameBytes(); + + /** + * repeated string primitive_properties = 2; + * @return A list containing the primitiveProperties. + */ + java.util.List + getPrimitivePropertiesList(); + /** + * repeated string primitive_properties = 2; + * @return The count of primitiveProperties. + */ + int getPrimitivePropertiesCount(); + /** + * repeated string primitive_properties = 2; + * @param index The index of the element to return. + * @return The primitiveProperties at the given index. + */ + java.lang.String getPrimitiveProperties(int index); + /** + * repeated string primitive_properties = 2; + * @param index The index of the value to return. + * @return The bytes of the primitiveProperties at the given index. + */ + com.google.protobuf.ByteString + getPrimitivePropertiesBytes(int index); + + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + java.util.List + getObjectPropertiesList(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + int getObjectPropertiesCount(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + java.util.List + getObjectPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.ObjectPropertiesRequest} + */ + public static final class ObjectPropertiesRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.ObjectPropertiesRequest) + ObjectPropertiesRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use ObjectPropertiesRequest.newBuilder() to construct. + private ObjectPropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ObjectPropertiesRequest() { + propName_ = ""; + primitiveProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + objectProperties_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ObjectPropertiesRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder.class); + } + + public static final int PROP_NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object propName_ = ""; + /** + * string prop_name = 1; + * @return The propName. + */ + @java.lang.Override + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } + } + /** + * string prop_name = 1; + * @return The bytes for propName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int PRIMITIVE_PROPERTIES_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private com.google.protobuf.LazyStringArrayList primitiveProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + /** + * repeated string primitive_properties = 2; + * @return A list containing the primitiveProperties. + */ + public com.google.protobuf.ProtocolStringList + getPrimitivePropertiesList() { + return primitiveProperties_; + } + /** + * repeated string primitive_properties = 2; + * @return The count of primitiveProperties. + */ + public int getPrimitivePropertiesCount() { + return primitiveProperties_.size(); + } + /** + * repeated string primitive_properties = 2; + * @param index The index of the element to return. + * @return The primitiveProperties at the given index. + */ + public java.lang.String getPrimitiveProperties(int index) { + return primitiveProperties_.get(index); + } + /** + * repeated string primitive_properties = 2; + * @param index The index of the value to return. + * @return The bytes of the primitiveProperties at the given index. + */ + public com.google.protobuf.ByteString + getPrimitivePropertiesBytes(int index) { + return primitiveProperties_.getByteString(index); + } + + public static final int OBJECT_PROPERTIES_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private java.util.List objectProperties_; + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public java.util.List getObjectPropertiesList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public java.util.List + getObjectPropertiesOrBuilderList() { + return objectProperties_; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public int getObjectPropertiesCount() { + return objectProperties_.size(); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { + return objectProperties_.get(index); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index) { + return objectProperties_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, propName_); + } + for (int i = 0; i < primitiveProperties_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, primitiveProperties_.getRaw(i)); + } + for (int i = 0; i < objectProperties_.size(); i++) { + output.writeMessage(3, objectProperties_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, propName_); + } + { + int dataSize = 0; + for (int i = 0; i < primitiveProperties_.size(); i++) { + dataSize += computeStringSizeNoTag(primitiveProperties_.getRaw(i)); + } + size += dataSize; + size += 1 * getPrimitivePropertiesList().size(); + } + for (int i = 0; i < objectProperties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, objectProperties_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest) obj; + + if (!getPropName() + .equals(other.getPropName())) return false; + if (!getPrimitivePropertiesList() + .equals(other.getPrimitivePropertiesList())) return false; + if (!getObjectPropertiesList() + .equals(other.getObjectPropertiesList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; + hash = (53 * hash) + getPropName().hashCode(); + if (getPrimitivePropertiesCount() > 0) { + hash = (37 * hash) + PRIMITIVE_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getPrimitivePropertiesList().hashCode(); + } + if (getObjectPropertiesCount() > 0) { + hash = (37 * hash) + OBJECT_PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getObjectPropertiesList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.ObjectPropertiesRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.ObjectPropertiesRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + propName_ = ""; + primitiveProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + } else { + objectProperties_ = null; + objectPropertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest result) { + if (objectPropertiesBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + objectProperties_ = java.util.Collections.unmodifiableList(objectProperties_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.objectProperties_ = objectProperties_; + } else { + result.objectProperties_ = objectPropertiesBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.propName_ = propName_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + primitiveProperties_.makeImmutable(); + result.primitiveProperties_ = primitiveProperties_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()) return this; + if (!other.getPropName().isEmpty()) { + propName_ = other.propName_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.primitiveProperties_.isEmpty()) { + if (primitiveProperties_.isEmpty()) { + primitiveProperties_ = other.primitiveProperties_; + bitField0_ |= 0x00000002; + } else { + ensurePrimitivePropertiesIsMutable(); + primitiveProperties_.addAll(other.primitiveProperties_); + } + onChanged(); + } + if (objectPropertiesBuilder_ == null) { + if (!other.objectProperties_.isEmpty()) { + if (objectProperties_.isEmpty()) { + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureObjectPropertiesIsMutable(); + objectProperties_.addAll(other.objectProperties_); + } + onChanged(); + } + } else { + if (!other.objectProperties_.isEmpty()) { + if (objectPropertiesBuilder_.isEmpty()) { + objectPropertiesBuilder_.dispose(); + objectPropertiesBuilder_ = null; + objectProperties_ = other.objectProperties_; + bitField0_ = (bitField0_ & ~0x00000004); + objectPropertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getObjectPropertiesFieldBuilder() : null; + } else { + objectPropertiesBuilder_.addAllMessages(other.objectProperties_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + propName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + ensurePrimitivePropertiesIsMutable(); + primitiveProperties_.add(s); + break; + } // case 18 + case 26: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.parser(), + extensionRegistry); + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(m); + } else { + objectPropertiesBuilder_.addMessage(m); + } + break; + } // case 26 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object propName_ = ""; + /** + * string prop_name = 1; + * @return The propName. + */ + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string prop_name = 1; + * @return The bytes for propName. + */ + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string prop_name = 1; + * @param value The propName to set. + * @return This builder for chaining. + */ + public Builder setPropName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + propName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string prop_name = 1; + * @return This builder for chaining. + */ + public Builder clearPropName() { + propName_ = getDefaultInstance().getPropName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string prop_name = 1; + * @param value The bytes for propName to set. + * @return This builder for chaining. + */ + public Builder setPropNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + propName_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringArrayList primitiveProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + private void ensurePrimitivePropertiesIsMutable() { + if (!primitiveProperties_.isModifiable()) { + primitiveProperties_ = new com.google.protobuf.LazyStringArrayList(primitiveProperties_); + } + bitField0_ |= 0x00000002; + } + /** + * repeated string primitive_properties = 2; + * @return A list containing the primitiveProperties. + */ + public com.google.protobuf.ProtocolStringList + getPrimitivePropertiesList() { + primitiveProperties_.makeImmutable(); + return primitiveProperties_; + } + /** + * repeated string primitive_properties = 2; + * @return The count of primitiveProperties. + */ + public int getPrimitivePropertiesCount() { + return primitiveProperties_.size(); + } + /** + * repeated string primitive_properties = 2; + * @param index The index of the element to return. + * @return The primitiveProperties at the given index. + */ + public java.lang.String getPrimitiveProperties(int index) { + return primitiveProperties_.get(index); + } + /** + * repeated string primitive_properties = 2; + * @param index The index of the value to return. + * @return The bytes of the primitiveProperties at the given index. + */ + public com.google.protobuf.ByteString + getPrimitivePropertiesBytes(int index) { + return primitiveProperties_.getByteString(index); + } + /** + * repeated string primitive_properties = 2; + * @param index The index to set the value at. + * @param value The primitiveProperties to set. + * @return This builder for chaining. + */ + public Builder setPrimitiveProperties( + int index, java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePrimitivePropertiesIsMutable(); + primitiveProperties_.set(index, value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * repeated string primitive_properties = 2; + * @param value The primitiveProperties to add. + * @return This builder for chaining. + */ + public Builder addPrimitiveProperties( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + ensurePrimitivePropertiesIsMutable(); + primitiveProperties_.add(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * repeated string primitive_properties = 2; + * @param values The primitiveProperties to add. + * @return This builder for chaining. + */ + public Builder addAllPrimitiveProperties( + java.lang.Iterable values) { + ensurePrimitivePropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, primitiveProperties_); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * repeated string primitive_properties = 2; + * @return This builder for chaining. + */ + public Builder clearPrimitiveProperties() { + primitiveProperties_ = + com.google.protobuf.LazyStringArrayList.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002);; + onChanged(); + return this; + } + /** + * repeated string primitive_properties = 2; + * @param value The bytes of the primitiveProperties to add. + * @return This builder for chaining. + */ + public Builder addPrimitivePropertiesBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + ensurePrimitivePropertiesIsMutable(); + primitiveProperties_.add(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private java.util.List objectProperties_ = + java.util.Collections.emptyList(); + private void ensureObjectPropertiesIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + objectProperties_ = new java.util.ArrayList(objectProperties_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> objectPropertiesBuilder_; + + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List getObjectPropertiesList() { + if (objectPropertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(objectProperties_); + } else { + return objectPropertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public int getObjectPropertiesCount() { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.size(); + } else { + return objectPropertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); + } else { + return objectPropertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder setObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.set(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest value) { + if (objectPropertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, value); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addObjectProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder builderForValue) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.add(index, builderForValue.build()); + onChanged(); + } else { + objectPropertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder addAllObjectProperties( + java.lang.Iterable values) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, objectProperties_); + onChanged(); + } else { + objectPropertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder clearObjectProperties() { + if (objectPropertiesBuilder_ == null) { + objectProperties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + objectPropertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public Builder removeObjectProperties(int index) { + if (objectPropertiesBuilder_ == null) { + ensureObjectPropertiesIsMutable(); + objectProperties_.remove(index); + onChanged(); + } else { + objectPropertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder getObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder getObjectPropertiesOrBuilder( + int index) { + if (objectPropertiesBuilder_ == null) { + return objectProperties_.get(index); } else { + return objectPropertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List + getObjectPropertiesOrBuilderList() { + if (objectPropertiesBuilder_ != null) { + return objectPropertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(objectProperties_); + } + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder() { + return getObjectPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder addObjectPropertiesBuilder( + int index) { + return getObjectPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.ObjectPropertiesRequest object_properties = 3; + */ + public java.util.List + getObjectPropertiesBuilderList() { + return getObjectPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder> + getObjectPropertiesFieldBuilder() { + if (objectPropertiesBuilder_ == null) { + objectPropertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequestOrBuilder>( + objectProperties_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + objectProperties_ = null; + } + return objectPropertiesBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.ObjectPropertiesRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.ObjectPropertiesRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ObjectPropertiesRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.ObjectPropertiesRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface RefPropertiesRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.RefPropertiesRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * string reference_property = 1; + * @return The referenceProperty. + */ + java.lang.String getReferenceProperty(); + /** + * string reference_property = 1; + * @return The bytes for referenceProperty. + */ + com.google.protobuf.ByteString + getReferencePropertyBytes(); + + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return Whether the properties field is set. + */ + boolean hasProperties(); + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return The properties. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties(); + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder(); + + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return Whether the metadata field is set. + */ + boolean hasMetadata(); + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return The metadata. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata(); + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder(); + + /** + * string target_collection = 4; + * @return The targetCollection. + */ + java.lang.String getTargetCollection(); + /** + * string target_collection = 4; + * @return The bytes for targetCollection. + */ + com.google.protobuf.ByteString + getTargetCollectionBytes(); + } + /** + * Protobuf type {@code weaviate.v1.RefPropertiesRequest} + */ + public static final class RefPropertiesRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.RefPropertiesRequest) + RefPropertiesRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use RefPropertiesRequest.newBuilder() to construct. + private RefPropertiesRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private RefPropertiesRequest() { + referenceProperty_ = ""; + targetCollection_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new RefPropertiesRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder.class); + } + + private int bitField0_; + public static final int REFERENCE_PROPERTY_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object referenceProperty_ = ""; + /** + * string reference_property = 1; + * @return The referenceProperty. + */ + @java.lang.Override + public java.lang.String getReferenceProperty() { + java.lang.Object ref = referenceProperty_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + referenceProperty_ = s; + return s; + } + } + /** + * string reference_property = 1; + * @return The bytes for referenceProperty. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getReferencePropertyBytes() { + java.lang.Object ref = referenceProperty_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + referenceProperty_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int PROPERTIES_FIELD_NUMBER = 2; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest properties_; + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return Whether the properties field is set. + */ + @java.lang.Override + public boolean hasProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return The properties. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + + public static final int METADATA_FIELD_NUMBER = 3; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest metadata_; + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return Whether the metadata field is set. + */ + @java.lang.Override + public boolean hasMetadata() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return The metadata. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + + public static final int TARGET_COLLECTION_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private volatile java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 4; + * @return The targetCollection. + */ + @java.lang.Override + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } + } + /** + * string target_collection = 4; + * @return The bytes for targetCollection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(referenceProperty_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, referenceProperty_); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(2, getProperties()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(3, getMetadata()); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, targetCollection_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(referenceProperty_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, referenceProperty_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getProperties()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getMetadata()); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, targetCollection_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest) obj; + + if (!getReferenceProperty() + .equals(other.getReferenceProperty())) return false; + if (hasProperties() != other.hasProperties()) return false; + if (hasProperties()) { + if (!getProperties() + .equals(other.getProperties())) return false; + } + if (hasMetadata() != other.hasMetadata()) return false; + if (hasMetadata()) { + if (!getMetadata() + .equals(other.getMetadata())) return false; + } + if (!getTargetCollection() + .equals(other.getTargetCollection())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + REFERENCE_PROPERTY_FIELD_NUMBER; + hash = (53 * hash) + getReferenceProperty().hashCode(); + if (hasProperties()) { + hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getProperties().hashCode(); + } + if (hasMetadata()) { + hash = (37 * hash) + METADATA_FIELD_NUMBER; + hash = (53 * hash) + getMetadata().hashCode(); + } + hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getTargetCollection().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.RefPropertiesRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.RefPropertiesRequest) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPropertiesFieldBuilder(); + getMetadataFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + referenceProperty_ = ""; + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + targetCollection_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesRequest_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.referenceProperty_ = referenceProperty_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.properties_ = propertiesBuilder_ == null + ? properties_ + : propertiesBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.metadata_ = metadataBuilder_ == null + ? metadata_ + : metadataBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.targetCollection_ = targetCollection_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest.getDefaultInstance()) return this; + if (!other.getReferenceProperty().isEmpty()) { + referenceProperty_ = other.referenceProperty_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (other.hasProperties()) { + mergeProperties(other.getProperties()); + } + if (other.hasMetadata()) { + mergeMetadata(other.getMetadata()); + } + if (!other.getTargetCollection().isEmpty()) { + targetCollection_ = other.targetCollection_; + bitField0_ |= 0x00000008; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + referenceProperty_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + input.readMessage( + getPropertiesFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + input.readMessage( + getMetadataFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 34: { + targetCollection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000008; + break; + } // case 34 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object referenceProperty_ = ""; + /** + * string reference_property = 1; + * @return The referenceProperty. + */ + public java.lang.String getReferenceProperty() { + java.lang.Object ref = referenceProperty_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + referenceProperty_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string reference_property = 1; + * @return The bytes for referenceProperty. + */ + public com.google.protobuf.ByteString + getReferencePropertyBytes() { + java.lang.Object ref = referenceProperty_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + referenceProperty_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string reference_property = 1; + * @param value The referenceProperty to set. + * @return This builder for chaining. + */ + public Builder setReferenceProperty( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + referenceProperty_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string reference_property = 1; + * @return This builder for chaining. + */ + public Builder clearReferenceProperty() { + referenceProperty_ = getDefaultInstance().getReferenceProperty(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string reference_property = 1; + * @param value The bytes for referenceProperty to set. + * @return This builder for chaining. + */ + public Builder setReferencePropertyBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + referenceProperty_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest properties_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> propertiesBuilder_; + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return Whether the properties field is set. + */ + public boolean hasProperties() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + * @return The properties. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest getProperties() { + if (propertiesBuilder_ == null) { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } else { + return propertiesBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public Builder setProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + properties_ = value; + } else { + propertiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public Builder setProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder builderForValue) { + if (propertiesBuilder_ == null) { + properties_ = builderForValue.build(); + } else { + propertiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public Builder mergeProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest value) { + if (propertiesBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + properties_ != null && + properties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance()) { + getPropertiesBuilder().mergeFrom(value); + } else { + properties_ = value; + } + } else { + propertiesBuilder_.mergeFrom(value); + } + if (properties_ != null) { + bitField0_ |= 0x00000002; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public Builder clearProperties() { + bitField0_ = (bitField0_ & ~0x00000002); + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder getPropertiesBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getPropertiesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder getPropertiesOrBuilder() { + if (propertiesBuilder_ != null) { + return propertiesBuilder_.getMessageOrBuilder(); + } else { + return properties_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.getDefaultInstance() : properties_; + } + } + /** + * .weaviate.v1.PropertiesRequest properties = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder> + getPropertiesFieldBuilder() { + if (propertiesBuilder_ == null) { + propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesRequestOrBuilder>( + getProperties(), + getParentForChildren(), + isClean()); + properties_ = null; + } + return propertiesBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest metadata_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder> metadataBuilder_; + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return Whether the metadata field is set. + */ + public boolean hasMetadata() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + * @return The metadata. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest getMetadata() { + if (metadataBuilder_ == null) { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } else { + return metadataBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest value) { + if (metadataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + metadata_ = value; + } else { + metadataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public Builder setMetadata( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder builderForValue) { + if (metadataBuilder_ == null) { + metadata_ = builderForValue.build(); + } else { + metadataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest value) { + if (metadataBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + metadata_ != null && + metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance()) { + getMetadataBuilder().mergeFrom(value); + } else { + metadata_ = value; + } + } else { + metadataBuilder_.mergeFrom(value); + } + if (metadata_ != null) { + bitField0_ |= 0x00000004; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public Builder clearMetadata() { + bitField0_ = (bitField0_ & ~0x00000004); + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder getMetadataBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getMetadataFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder getMetadataOrBuilder() { + if (metadataBuilder_ != null) { + return metadataBuilder_.getMessageOrBuilder(); + } else { + return metadata_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.getDefaultInstance() : metadata_; + } + } + /** + * .weaviate.v1.MetadataRequest metadata = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder> + getMetadataFieldBuilder() { + if (metadataBuilder_ == null) { + metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequest.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataRequestOrBuilder>( + getMetadata(), + getParentForChildren(), + isClean()); + metadata_ = null; + } + return metadataBuilder_; + } + + private java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 4; + * @return The targetCollection. + */ + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string target_collection = 4; + * @return The bytes for targetCollection. + */ + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string target_collection = 4; + * @param value The targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + targetCollection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * string target_collection = 4; + * @return This builder for chaining. + */ + public Builder clearTargetCollection() { + targetCollection_ = getDefaultInstance().getTargetCollection(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + /** + * string target_collection = 4; + * @param value The bytes for targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + targetCollection_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.RefPropertiesRequest) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.RefPropertiesRequest) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public RefPropertiesRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface RerankOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.Rerank) + com.google.protobuf.MessageOrBuilder { + + /** + * string property = 1; + * @return The property. + */ + java.lang.String getProperty(); + /** + * string property = 1; + * @return The bytes for property. + */ + com.google.protobuf.ByteString + getPropertyBytes(); + + /** + * optional string query = 2; + * @return Whether the query field is set. + */ + boolean hasQuery(); + /** + * optional string query = 2; + * @return The query. + */ + java.lang.String getQuery(); + /** + * optional string query = 2; + * @return The bytes for query. + */ + com.google.protobuf.ByteString + getQueryBytes(); + } + /** + * Protobuf type {@code weaviate.v1.Rerank} + */ + public static final class Rerank extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.Rerank) + RerankOrBuilder { + private static final long serialVersionUID = 0L; + // Use Rerank.newBuilder() to construct. + private Rerank(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Rerank() { + property_ = ""; + query_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Rerank(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder.class); + } + + private int bitField0_; + public static final int PROPERTY_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object property_ = ""; + /** + * string property = 1; + * @return The property. + */ + @java.lang.Override + public java.lang.String getProperty() { + java.lang.Object ref = property_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + property_ = s; + return s; + } + } + /** + * string property = 1; + * @return The bytes for property. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getPropertyBytes() { + java.lang.Object ref = property_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + property_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int QUERY_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object query_ = ""; + /** + * optional string query = 2; + * @return Whether the query field is set. + */ + @java.lang.Override + public boolean hasQuery() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string query = 2; + * @return The query. + */ + @java.lang.Override + public java.lang.String getQuery() { + java.lang.Object ref = query_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + query_ = s; + return s; + } + } + /** + * optional string query = 2; + * @return The bytes for query. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getQueryBytes() { + java.lang.Object ref = query_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + query_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(property_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, property_); + } + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, query_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(property_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, property_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, query_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank) obj; + + if (!getProperty() + .equals(other.getProperty())) return false; + if (hasQuery() != other.hasQuery()) return false; + if (hasQuery()) { + if (!getQuery() + .equals(other.getQuery())) return false; + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + PROPERTY_FIELD_NUMBER; + hash = (53 * hash) + getProperty().hashCode(); + if (hasQuery()) { + hash = (37 * hash) + QUERY_FIELD_NUMBER; + hash = (53 * hash) + getQuery().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.Rerank} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.Rerank) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + property_ = ""; + query_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_Rerank_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.property_ = property_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.query_ = query_; + to_bitField0_ |= 0x00000001; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank.getDefaultInstance()) return this; + if (!other.getProperty().isEmpty()) { + property_ = other.property_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (other.hasQuery()) { + query_ = other.query_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + property_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + query_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object property_ = ""; + /** + * string property = 1; + * @return The property. + */ + public java.lang.String getProperty() { + java.lang.Object ref = property_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + property_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string property = 1; + * @return The bytes for property. + */ + public com.google.protobuf.ByteString + getPropertyBytes() { + java.lang.Object ref = property_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + property_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string property = 1; + * @param value The property to set. + * @return This builder for chaining. + */ + public Builder setProperty( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + property_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string property = 1; + * @return This builder for chaining. + */ + public Builder clearProperty() { + property_ = getDefaultInstance().getProperty(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string property = 1; + * @param value The bytes for property to set. + * @return This builder for chaining. + */ + public Builder setPropertyBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + property_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private java.lang.Object query_ = ""; + /** + * optional string query = 2; + * @return Whether the query field is set. + */ + public boolean hasQuery() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string query = 2; + * @return The query. + */ + public java.lang.String getQuery() { + java.lang.Object ref = query_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + query_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string query = 2; + * @return The bytes for query. + */ + public com.google.protobuf.ByteString + getQueryBytes() { + java.lang.Object ref = query_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + query_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string query = 2; + * @param value The query to set. + * @return This builder for chaining. + */ + public Builder setQuery( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + query_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * optional string query = 2; + * @return This builder for chaining. + */ + public Builder clearQuery() { + query_ = getDefaultInstance().getQuery(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * optional string query = 2; + * @param value The bytes for query to set. + * @return This builder for chaining. + */ + public Builder setQueryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + query_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.Rerank) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.Rerank) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Rerank parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.Rerank getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SearchReplyOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchReply) + com.google.protobuf.MessageOrBuilder { + + /** + * float took = 1; + * @return The took. + */ + float getTook(); + + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + java.util.List + getResultsList(); + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getResults(int index); + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + int getResultsCount(); + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + java.util.List + getResultsOrBuilderList(); + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( + int index); + + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return Whether the generativeGroupedResult field is set. + */ + @java.lang.Deprecated boolean hasGenerativeGroupedResult(); + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The generativeGroupedResult. + */ + @java.lang.Deprecated java.lang.String getGenerativeGroupedResult(); + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The bytes for generativeGroupedResult. + */ + @java.lang.Deprecated com.google.protobuf.ByteString + getGenerativeGroupedResultBytes(); + + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + java.util.List + getGroupByResultsList(); + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index); + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + int getGroupByResultsCount(); + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + java.util.List + getGroupByResultsOrBuilderList(); + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( + int index); + + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return Whether the generativeGroupedResults field is set. + */ + boolean hasGenerativeGroupedResults(); + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return The generativeGroupedResults. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults(); + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder(); + } + /** + * Protobuf type {@code weaviate.v1.SearchReply} + */ + public static final class SearchReply extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.SearchReply) + SearchReplyOrBuilder { + private static final long serialVersionUID = 0L; + // Use SearchReply.newBuilder() to construct. + private SearchReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SearchReply() { + results_ = java.util.Collections.emptyList(); + generativeGroupedResult_ = ""; + groupByResults_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SearchReply(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.Builder.class); + } + + private int bitField0_; + public static final int TOOK_FIELD_NUMBER = 1; + private float took_ = 0F; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + + public static final int RESULTS_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List results_; + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + @java.lang.Override + public java.util.List getResultsList() { + return results_; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + @java.lang.Override + public java.util.List + getResultsOrBuilderList() { + return results_; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + @java.lang.Override + public int getResultsCount() { + return results_.size(); + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getResults(int index) { + return results_.get(index); + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( + int index) { + return results_.get(index); + } + + public static final int GENERATIVE_GROUPED_RESULT_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object generativeGroupedResult_ = ""; + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return Whether the generativeGroupedResult field is set. + */ + @java.lang.Override + @java.lang.Deprecated public boolean hasGenerativeGroupedResult() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The generativeGroupedResult. + */ + @java.lang.Override + @java.lang.Deprecated public java.lang.String getGenerativeGroupedResult() { + java.lang.Object ref = generativeGroupedResult_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + generativeGroupedResult_ = s; + return s; + } + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The bytes for generativeGroupedResult. + */ + @java.lang.Override + @java.lang.Deprecated public com.google.protobuf.ByteString + getGenerativeGroupedResultBytes() { + java.lang.Object ref = generativeGroupedResult_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + generativeGroupedResult_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int GROUP_BY_RESULTS_FIELD_NUMBER = 4; + @SuppressWarnings("serial") + private java.util.List groupByResults_; + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + @java.lang.Override + public java.util.List getGroupByResultsList() { + return groupByResults_; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + @java.lang.Override + public java.util.List + getGroupByResultsOrBuilderList() { + return groupByResults_; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + @java.lang.Override + public int getGroupByResultsCount() { + return groupByResults_.size(); + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index) { + return groupByResults_.get(index); + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( + int index) { + return groupByResults_.get(index); + } + + public static final int GENERATIVE_GROUPED_RESULTS_FIELD_NUMBER = 5; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generativeGroupedResults_; + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return Whether the generativeGroupedResults field is set. + */ + @java.lang.Override + public boolean hasGenerativeGroupedResults() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return The generativeGroupedResults. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults() { + return generativeGroupedResults_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder() { + return generativeGroupedResults_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + output.writeFloat(1, took_); + } + for (int i = 0; i < results_.size(); i++) { + output.writeMessage(2, results_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, generativeGroupedResult_); + } + for (int i = 0; i < groupByResults_.size(); i++) { + output.writeMessage(4, groupByResults_.get(i)); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(5, getGenerativeGroupedResults()); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (java.lang.Float.floatToRawIntBits(took_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(1, took_); + } + for (int i = 0; i < results_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, results_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, generativeGroupedResult_); + } + for (int i = 0; i < groupByResults_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, groupByResults_.get(i)); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getGenerativeGroupedResults()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply) obj; + + if (java.lang.Float.floatToIntBits(getTook()) + != java.lang.Float.floatToIntBits( + other.getTook())) return false; + if (!getResultsList() + .equals(other.getResultsList())) return false; + if (hasGenerativeGroupedResult() != other.hasGenerativeGroupedResult()) return false; + if (hasGenerativeGroupedResult()) { + if (!getGenerativeGroupedResult() + .equals(other.getGenerativeGroupedResult())) return false; + } + if (!getGroupByResultsList() + .equals(other.getGroupByResultsList())) return false; + if (hasGenerativeGroupedResults() != other.hasGenerativeGroupedResults()) return false; + if (hasGenerativeGroupedResults()) { + if (!getGenerativeGroupedResults() + .equals(other.getGenerativeGroupedResults())) return false; + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TOOK_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getTook()); + if (getResultsCount() > 0) { + hash = (37 * hash) + RESULTS_FIELD_NUMBER; + hash = (53 * hash) + getResultsList().hashCode(); + } + if (hasGenerativeGroupedResult()) { + hash = (37 * hash) + GENERATIVE_GROUPED_RESULT_FIELD_NUMBER; + hash = (53 * hash) + getGenerativeGroupedResult().hashCode(); + } + if (getGroupByResultsCount() > 0) { + hash = (37 * hash) + GROUP_BY_RESULTS_FIELD_NUMBER; + hash = (53 * hash) + getGroupByResultsList().hashCode(); + } + if (hasGenerativeGroupedResults()) { + hash = (37 * hash) + GENERATIVE_GROUPED_RESULTS_FIELD_NUMBER; + hash = (53 * hash) + getGenerativeGroupedResults().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.SearchReply} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchReply) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReplyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getResultsFieldBuilder(); + getGroupByResultsFieldBuilder(); + getGenerativeGroupedResultsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + took_ = 0F; + if (resultsBuilder_ == null) { + results_ = java.util.Collections.emptyList(); + } else { + results_ = null; + resultsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + generativeGroupedResult_ = ""; + if (groupByResultsBuilder_ == null) { + groupByResults_ = java.util.Collections.emptyList(); + } else { + groupByResults_ = null; + groupByResultsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + generativeGroupedResults_ = null; + if (generativeGroupedResultsBuilder_ != null) { + generativeGroupedResultsBuilder_.dispose(); + generativeGroupedResultsBuilder_ = null; + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchReply_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply result) { + if (resultsBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + results_ = java.util.Collections.unmodifiableList(results_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.results_ = results_; + } else { + result.results_ = resultsBuilder_.build(); + } + if (groupByResultsBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0)) { + groupByResults_ = java.util.Collections.unmodifiableList(groupByResults_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.groupByResults_ = groupByResults_; + } else { + result.groupByResults_ = groupByResultsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.took_ = took_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000004) != 0)) { + result.generativeGroupedResult_ = generativeGroupedResult_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.generativeGroupedResults_ = generativeGroupedResultsBuilder_ == null + ? generativeGroupedResults_ + : generativeGroupedResultsBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply.getDefaultInstance()) return this; + if (other.getTook() != 0F) { + setTook(other.getTook()); + } + if (resultsBuilder_ == null) { + if (!other.results_.isEmpty()) { + if (results_.isEmpty()) { + results_ = other.results_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureResultsIsMutable(); + results_.addAll(other.results_); + } + onChanged(); + } + } else { + if (!other.results_.isEmpty()) { + if (resultsBuilder_.isEmpty()) { + resultsBuilder_.dispose(); + resultsBuilder_ = null; + results_ = other.results_; + bitField0_ = (bitField0_ & ~0x00000002); + resultsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getResultsFieldBuilder() : null; + } else { + resultsBuilder_.addAllMessages(other.results_); + } + } + } + if (other.hasGenerativeGroupedResult()) { + generativeGroupedResult_ = other.generativeGroupedResult_; + bitField0_ |= 0x00000004; + onChanged(); + } + if (groupByResultsBuilder_ == null) { + if (!other.groupByResults_.isEmpty()) { + if (groupByResults_.isEmpty()) { + groupByResults_ = other.groupByResults_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureGroupByResultsIsMutable(); + groupByResults_.addAll(other.groupByResults_); + } + onChanged(); + } + } else { + if (!other.groupByResults_.isEmpty()) { + if (groupByResultsBuilder_.isEmpty()) { + groupByResultsBuilder_.dispose(); + groupByResultsBuilder_ = null; + groupByResults_ = other.groupByResults_; + bitField0_ = (bitField0_ & ~0x00000008); + groupByResultsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getGroupByResultsFieldBuilder() : null; + } else { + groupByResultsBuilder_.addAllMessages(other.groupByResults_); + } + } + } + if (other.hasGenerativeGroupedResults()) { + mergeGenerativeGroupedResults(other.getGenerativeGroupedResults()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 13: { + took_ = input.readFloat(); + bitField0_ |= 0x00000001; + break; + } // case 13 + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.parser(), + extensionRegistry); + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + results_.add(m); + } else { + resultsBuilder_.addMessage(m); + } + break; + } // case 18 + case 26: { + generativeGroupedResult_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000004; + break; + } // case 26 + case 34: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.parser(), + extensionRegistry); + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + groupByResults_.add(m); + } else { + groupByResultsBuilder_.addMessage(m); + } + break; + } // case 34 + case 42: { + input.readMessage( + getGenerativeGroupedResultsFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000010; + break; + } // case 42 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private float took_ ; + /** + * float took = 1; + * @return The took. + */ + @java.lang.Override + public float getTook() { + return took_; + } + /** + * float took = 1; + * @param value The took to set. + * @return This builder for chaining. + */ + public Builder setTook(float value) { + + took_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * float took = 1; + * @return This builder for chaining. + */ + public Builder clearTook() { + bitField0_ = (bitField0_ & ~0x00000001); + took_ = 0F; + onChanged(); + return this; + } + + private java.util.List results_ = + java.util.Collections.emptyList(); + private void ensureResultsIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + results_ = new java.util.ArrayList(results_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder> resultsBuilder_; + + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public java.util.List getResultsList() { + if (resultsBuilder_ == null) { + return java.util.Collections.unmodifiableList(results_); + } else { + return resultsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public int getResultsCount() { + if (resultsBuilder_ == null) { + return results_.size(); + } else { + return resultsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getResults(int index) { + if (resultsBuilder_ == null) { + return results_.get(index); + } else { + return resultsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder setResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (resultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureResultsIsMutable(); + results_.set(index, value); + onChanged(); + } else { + resultsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder setResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + results_.set(index, builderForValue.build()); + onChanged(); + } else { + resultsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder addResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (resultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureResultsIsMutable(); + results_.add(value); + onChanged(); + } else { + resultsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder addResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (resultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureResultsIsMutable(); + results_.add(index, value); + onChanged(); + } else { + resultsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder addResults( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + results_.add(builderForValue.build()); + onChanged(); + } else { + resultsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder addResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + results_.add(index, builderForValue.build()); + onChanged(); + } else { + resultsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder addAllResults( + java.lang.Iterable values) { + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, results_); + onChanged(); + } else { + resultsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder clearResults() { + if (resultsBuilder_ == null) { + results_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + resultsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public Builder removeResults(int index) { + if (resultsBuilder_ == null) { + ensureResultsIsMutable(); + results_.remove(index); + onChanged(); + } else { + resultsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder getResultsBuilder( + int index) { + return getResultsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getResultsOrBuilder( + int index) { + if (resultsBuilder_ == null) { + return results_.get(index); } else { + return resultsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public java.util.List + getResultsOrBuilderList() { + if (resultsBuilder_ != null) { + return resultsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(results_); + } + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder addResultsBuilder() { + return getResultsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder addResultsBuilder( + int index) { + return getResultsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.SearchResult results = 2; + */ + public java.util.List + getResultsBuilderList() { + return getResultsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder> + getResultsFieldBuilder() { + if (resultsBuilder_ == null) { + resultsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder>( + results_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + results_ = null; + } + return resultsBuilder_; + } + + private java.lang.Object generativeGroupedResult_ = ""; + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return Whether the generativeGroupedResult field is set. + */ + @java.lang.Deprecated public boolean hasGenerativeGroupedResult() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The generativeGroupedResult. + */ + @java.lang.Deprecated public java.lang.String getGenerativeGroupedResult() { + java.lang.Object ref = generativeGroupedResult_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + generativeGroupedResult_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return The bytes for generativeGroupedResult. + */ + @java.lang.Deprecated public com.google.protobuf.ByteString + getGenerativeGroupedResultBytes() { + java.lang.Object ref = generativeGroupedResult_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + generativeGroupedResult_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @param value The generativeGroupedResult to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setGenerativeGroupedResult( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + generativeGroupedResult_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearGenerativeGroupedResult() { + generativeGroupedResult_ = getDefaultInstance().getGenerativeGroupedResult(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + /** + * optional string generative_grouped_result = 3 [deprecated = true]; + * @deprecated weaviate.v1.SearchReply.generative_grouped_result is deprecated. + * See v1/search_get.proto;l=114 + * @param value The bytes for generativeGroupedResult to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setGenerativeGroupedResultBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + generativeGroupedResult_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + + private java.util.List groupByResults_ = + java.util.Collections.emptyList(); + private void ensureGroupByResultsIsMutable() { + if (!((bitField0_ & 0x00000008) != 0)) { + groupByResults_ = new java.util.ArrayList(groupByResults_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder> groupByResultsBuilder_; + + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public java.util.List getGroupByResultsList() { + if (groupByResultsBuilder_ == null) { + return java.util.Collections.unmodifiableList(groupByResults_); + } else { + return groupByResultsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public int getGroupByResultsCount() { + if (groupByResultsBuilder_ == null) { + return groupByResults_.size(); + } else { + return groupByResultsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getGroupByResults(int index) { + if (groupByResultsBuilder_ == null) { + return groupByResults_.get(index); + } else { + return groupByResultsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder setGroupByResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult value) { + if (groupByResultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupByResultsIsMutable(); + groupByResults_.set(index, value); + onChanged(); + } else { + groupByResultsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder setGroupByResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + groupByResults_.set(index, builderForValue.build()); + onChanged(); + } else { + groupByResultsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder addGroupByResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult value) { + if (groupByResultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupByResultsIsMutable(); + groupByResults_.add(value); + onChanged(); + } else { + groupByResultsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder addGroupByResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult value) { + if (groupByResultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupByResultsIsMutable(); + groupByResults_.add(index, value); + onChanged(); + } else { + groupByResultsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder addGroupByResults( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + groupByResults_.add(builderForValue.build()); + onChanged(); + } else { + groupByResultsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder addGroupByResults( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder builderForValue) { + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + groupByResults_.add(index, builderForValue.build()); + onChanged(); + } else { + groupByResultsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder addAllGroupByResults( + java.lang.Iterable values) { + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, groupByResults_); + onChanged(); + } else { + groupByResultsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder clearGroupByResults() { + if (groupByResultsBuilder_ == null) { + groupByResults_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + groupByResultsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public Builder removeGroupByResults(int index) { + if (groupByResultsBuilder_ == null) { + ensureGroupByResultsIsMutable(); + groupByResults_.remove(index); + onChanged(); + } else { + groupByResultsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder getGroupByResultsBuilder( + int index) { + return getGroupByResultsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder getGroupByResultsOrBuilder( + int index) { + if (groupByResultsBuilder_ == null) { + return groupByResults_.get(index); } else { + return groupByResultsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public java.util.List + getGroupByResultsOrBuilderList() { + if (groupByResultsBuilder_ != null) { + return groupByResultsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(groupByResults_); + } + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder addGroupByResultsBuilder() { + return getGroupByResultsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder addGroupByResultsBuilder( + int index) { + return getGroupByResultsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.GroupByResult group_by_results = 4; + */ + public java.util.List + getGroupByResultsBuilderList() { + return getGroupByResultsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder> + getGroupByResultsFieldBuilder() { + if (groupByResultsBuilder_ == null) { + groupByResultsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder>( + groupByResults_, + ((bitField0_ & 0x00000008) != 0), + getParentForChildren(), + isClean()); + groupByResults_ = null; + } + return groupByResultsBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generativeGroupedResults_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeGroupedResultsBuilder_; + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return Whether the generativeGroupedResults field is set. + */ + public boolean hasGenerativeGroupedResults() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + * @return The generativeGroupedResults. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeGroupedResults() { + if (generativeGroupedResultsBuilder_ == null) { + return generativeGroupedResults_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; + } else { + return generativeGroupedResultsBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public Builder setGenerativeGroupedResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeGroupedResultsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + generativeGroupedResults_ = value; + } else { + generativeGroupedResultsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public Builder setGenerativeGroupedResults( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { + if (generativeGroupedResultsBuilder_ == null) { + generativeGroupedResults_ = builderForValue.build(); + } else { + generativeGroupedResultsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public Builder mergeGenerativeGroupedResults(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeGroupedResultsBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0) && + generativeGroupedResults_ != null && + generativeGroupedResults_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { + getGenerativeGroupedResultsBuilder().mergeFrom(value); + } else { + generativeGroupedResults_ = value; + } + } else { + generativeGroupedResultsBuilder_.mergeFrom(value); + } + if (generativeGroupedResults_ != null) { + bitField0_ |= 0x00000010; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public Builder clearGenerativeGroupedResults() { + bitField0_ = (bitField0_ & ~0x00000010); + generativeGroupedResults_ = null; + if (generativeGroupedResultsBuilder_ != null) { + generativeGroupedResultsBuilder_.dispose(); + generativeGroupedResultsBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeGroupedResultsBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getGenerativeGroupedResultsFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeGroupedResultsOrBuilder() { + if (generativeGroupedResultsBuilder_ != null) { + return generativeGroupedResultsBuilder_.getMessageOrBuilder(); + } else { + return generativeGroupedResults_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeGroupedResults_; + } + } + /** + * optional .weaviate.v1.GenerativeResult generative_grouped_results = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> + getGenerativeGroupedResultsFieldBuilder() { + if (generativeGroupedResultsBuilder_ == null) { + generativeGroupedResultsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder>( + getGenerativeGroupedResults(), + getParentForChildren(), + isClean()); + generativeGroupedResults_ = null; + } + return generativeGroupedResultsBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchReply) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.SearchReply) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SearchReply parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchReply getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface RerankReplyOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.RerankReply) + com.google.protobuf.MessageOrBuilder { + + /** + * double score = 1; + * @return The score. + */ + double getScore(); + } + /** + * Protobuf type {@code weaviate.v1.RerankReply} + */ + public static final class RerankReply extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.RerankReply) + RerankReplyOrBuilder { + private static final long serialVersionUID = 0L; + // Use RerankReply.newBuilder() to construct. + private RerankReply(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private RerankReply() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new RerankReply(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder.class); + } + + public static final int SCORE_FIELD_NUMBER = 1; + private double score_ = 0D; + /** + * double score = 1; + * @return The score. + */ + @java.lang.Override + public double getScore() { + return score_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (java.lang.Double.doubleToRawLongBits(score_) != 0) { + output.writeDouble(1, score_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (java.lang.Double.doubleToRawLongBits(score_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(1, score_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply) obj; + + if (java.lang.Double.doubleToLongBits(getScore()) + != java.lang.Double.doubleToLongBits( + other.getScore())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SCORE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getScore())); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.RerankReply} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.RerankReply) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + score_ = 0D; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RerankReply_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.score_ = score_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance()) return this; + if (other.getScore() != 0D) { + setScore(other.getScore()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 9: { + score_ = input.readDouble(); + bitField0_ |= 0x00000001; + break; + } // case 9 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private double score_ ; + /** + * double score = 1; + * @return The score. + */ + @java.lang.Override + public double getScore() { + return score_; + } + /** + * double score = 1; + * @param value The score to set. + * @return This builder for chaining. + */ + public Builder setScore(double value) { + + score_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * double score = 1; + * @return This builder for chaining. + */ + public Builder clearScore() { + bitField0_ = (bitField0_ & ~0x00000001); + score_ = 0D; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.RerankReply) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.RerankReply) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public RerankReply parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GroupByResultOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.GroupByResult) + com.google.protobuf.MessageOrBuilder { + + /** + * string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * float min_distance = 2; + * @return The minDistance. + */ + float getMinDistance(); + + /** + * float max_distance = 3; + * @return The maxDistance. + */ + float getMaxDistance(); + + /** + * int64 number_of_objects = 4; + * @return The numberOfObjects. + */ + long getNumberOfObjects(); + + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + java.util.List + getObjectsList(); + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getObjects(int index); + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + int getObjectsCount(); + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + java.util.List + getObjectsOrBuilderList(); + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( + int index); + + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return Whether the rerank field is set. + */ + boolean hasRerank(); + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return The rerank. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getRerank(); + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder(); + + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return Whether the generative field is set. + */ + @java.lang.Deprecated boolean hasGenerative(); + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return The generative. + */ + @java.lang.Deprecated io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getGenerative(); + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder(); + + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return Whether the generativeResult field is set. + */ + boolean hasGenerativeResult(); + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return The generativeResult. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeResult(); + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder(); + } + /** + * Protobuf type {@code weaviate.v1.GroupByResult} + */ + public static final class GroupByResult extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.GroupByResult) + GroupByResultOrBuilder { + private static final long serialVersionUID = 0L; + // Use GroupByResult.newBuilder() to construct. + private GroupByResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GroupByResult() { + name_ = ""; + objects_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GroupByResult(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object name_ = ""; + /** + * string name = 1; + * @return The name. + */ + @java.lang.Override + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string name = 1; + * @return The bytes for name. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int MIN_DISTANCE_FIELD_NUMBER = 2; + private float minDistance_ = 0F; + /** + * float min_distance = 2; + * @return The minDistance. + */ + @java.lang.Override + public float getMinDistance() { + return minDistance_; + } + + public static final int MAX_DISTANCE_FIELD_NUMBER = 3; + private float maxDistance_ = 0F; + /** + * float max_distance = 3; + * @return The maxDistance. + */ + @java.lang.Override + public float getMaxDistance() { + return maxDistance_; + } + + public static final int NUMBER_OF_OBJECTS_FIELD_NUMBER = 4; + private long numberOfObjects_ = 0L; + /** + * int64 number_of_objects = 4; + * @return The numberOfObjects. + */ + @java.lang.Override + public long getNumberOfObjects() { + return numberOfObjects_; + } + + public static final int OBJECTS_FIELD_NUMBER = 5; + @SuppressWarnings("serial") + private java.util.List objects_; + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + @java.lang.Override + public java.util.List getObjectsList() { + return objects_; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + @java.lang.Override + public java.util.List + getObjectsOrBuilderList() { + return objects_; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + @java.lang.Override + public int getObjectsCount() { + return objects_.size(); + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getObjects(int index) { + return objects_.get(index); + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( + int index) { + return objects_.get(index); + } + + public static final int RERANK_FIELD_NUMBER = 6; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply rerank_; + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return Whether the rerank field is set. + */ + @java.lang.Override + public boolean hasRerank() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return The rerank. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getRerank() { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder() { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; + } + + public static final int GENERATIVE_FIELD_NUMBER = 7; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply generative_; + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return Whether the generative field is set. + */ + @java.lang.Override + @java.lang.Deprecated public boolean hasGenerative() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return The generative. + */ + @java.lang.Override + @java.lang.Deprecated public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getGenerative() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Override + @java.lang.Deprecated public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; + } + + public static final int GENERATIVE_RESULT_FIELD_NUMBER = 8; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generativeResult_; + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return Whether the generativeResult field is set. + */ + @java.lang.Override + public boolean hasGenerativeResult() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return The generativeResult. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeResult() { + return generativeResult_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder() { + return generativeResult_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (java.lang.Float.floatToRawIntBits(minDistance_) != 0) { + output.writeFloat(2, minDistance_); + } + if (java.lang.Float.floatToRawIntBits(maxDistance_) != 0) { + output.writeFloat(3, maxDistance_); + } + if (numberOfObjects_ != 0L) { + output.writeInt64(4, numberOfObjects_); + } + for (int i = 0; i < objects_.size(); i++) { + output.writeMessage(5, objects_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(6, getRerank()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(7, getGenerative()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(8, getGenerativeResult()); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (java.lang.Float.floatToRawIntBits(minDistance_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(2, minDistance_); + } + if (java.lang.Float.floatToRawIntBits(maxDistance_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(3, maxDistance_); + } + if (numberOfObjects_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(4, numberOfObjects_); + } + for (int i = 0; i < objects_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, objects_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getRerank()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getGenerative()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, getGenerativeResult()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult) obj; + + if (!getName() + .equals(other.getName())) return false; + if (java.lang.Float.floatToIntBits(getMinDistance()) + != java.lang.Float.floatToIntBits( + other.getMinDistance())) return false; + if (java.lang.Float.floatToIntBits(getMaxDistance()) + != java.lang.Float.floatToIntBits( + other.getMaxDistance())) return false; + if (getNumberOfObjects() + != other.getNumberOfObjects()) return false; + if (!getObjectsList() + .equals(other.getObjectsList())) return false; + if (hasRerank() != other.hasRerank()) return false; + if (hasRerank()) { + if (!getRerank() + .equals(other.getRerank())) return false; + } + if (hasGenerative() != other.hasGenerative()) return false; + if (hasGenerative()) { + if (!getGenerative() + .equals(other.getGenerative())) return false; + } + if (hasGenerativeResult() != other.hasGenerativeResult()) return false; + if (hasGenerativeResult()) { + if (!getGenerativeResult() + .equals(other.getGenerativeResult())) return false; + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + MIN_DISTANCE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getMinDistance()); + hash = (37 * hash) + MAX_DISTANCE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getMaxDistance()); + hash = (37 * hash) + NUMBER_OF_OBJECTS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getNumberOfObjects()); + if (getObjectsCount() > 0) { + hash = (37 * hash) + OBJECTS_FIELD_NUMBER; + hash = (53 * hash) + getObjectsList().hashCode(); + } + if (hasRerank()) { + hash = (37 * hash) + RERANK_FIELD_NUMBER; + hash = (53 * hash) + getRerank().hashCode(); + } + if (hasGenerative()) { + hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; + hash = (53 * hash) + getGenerative().hashCode(); + } + if (hasGenerativeResult()) { + hash = (37 * hash) + GENERATIVE_RESULT_FIELD_NUMBER; + hash = (53 * hash) + getGenerativeResult().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.GroupByResult} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.GroupByResult) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResultOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getObjectsFieldBuilder(); + getRerankFieldBuilder(); + getGenerativeFieldBuilder(); + getGenerativeResultFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + name_ = ""; + minDistance_ = 0F; + maxDistance_ = 0F; + numberOfObjects_ = 0L; + if (objectsBuilder_ == null) { + objects_ = java.util.Collections.emptyList(); + } else { + objects_ = null; + objectsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + rerank_ = null; + if (rerankBuilder_ != null) { + rerankBuilder_.dispose(); + rerankBuilder_ = null; + } + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + generativeResult_ = null; + if (generativeResultBuilder_ != null) { + generativeResultBuilder_.dispose(); + generativeResultBuilder_ = null; + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_GroupByResult_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult result) { + if (objectsBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0)) { + objects_ = java.util.Collections.unmodifiableList(objects_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.objects_ = objects_; + } else { + result.objects_ = objectsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.name_ = name_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.minDistance_ = minDistance_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.maxDistance_ = maxDistance_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.numberOfObjects_ = numberOfObjects_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000020) != 0)) { + result.rerank_ = rerankBuilder_ == null + ? rerank_ + : rerankBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.generative_ = generativeBuilder_ == null + ? generative_ + : generativeBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + result.generativeResult_ = generativeResultBuilder_ == null + ? generativeResult_ + : generativeResultBuilder_.build(); + to_bitField0_ |= 0x00000004; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (other.getMinDistance() != 0F) { + setMinDistance(other.getMinDistance()); + } + if (other.getMaxDistance() != 0F) { + setMaxDistance(other.getMaxDistance()); + } + if (other.getNumberOfObjects() != 0L) { + setNumberOfObjects(other.getNumberOfObjects()); + } + if (objectsBuilder_ == null) { + if (!other.objects_.isEmpty()) { + if (objects_.isEmpty()) { + objects_ = other.objects_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureObjectsIsMutable(); + objects_.addAll(other.objects_); + } + onChanged(); + } + } else { + if (!other.objects_.isEmpty()) { + if (objectsBuilder_.isEmpty()) { + objectsBuilder_.dispose(); + objectsBuilder_ = null; + objects_ = other.objects_; + bitField0_ = (bitField0_ & ~0x00000010); + objectsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getObjectsFieldBuilder() : null; + } else { + objectsBuilder_.addAllMessages(other.objects_); + } + } + } + if (other.hasRerank()) { + mergeRerank(other.getRerank()); + } + if (other.hasGenerative()) { + mergeGenerative(other.getGenerative()); + } + if (other.hasGenerativeResult()) { + mergeGenerativeResult(other.getGenerativeResult()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + name_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 21: { + minDistance_ = input.readFloat(); + bitField0_ |= 0x00000002; + break; + } // case 21 + case 29: { + maxDistance_ = input.readFloat(); + bitField0_ |= 0x00000004; + break; + } // case 29 + case 32: { + numberOfObjects_ = input.readInt64(); + bitField0_ |= 0x00000008; + break; + } // case 32 + case 42: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.parser(), + extensionRegistry); + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + objects_.add(m); + } else { + objectsBuilder_.addMessage(m); + } + break; + } // case 42 + case 50: { + input.readMessage( + getRerankFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000020; + break; + } // case 50 + case 58: { + input.readMessage( + getGenerativeFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000040; + break; + } // case 58 + case 66: { + input.readMessage( + getGenerativeResultFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000080; + break; + } // case 66 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + name_ = getDefaultInstance().getName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private float minDistance_ ; + /** + * float min_distance = 2; + * @return The minDistance. + */ + @java.lang.Override + public float getMinDistance() { + return minDistance_; + } + /** + * float min_distance = 2; + * @param value The minDistance to set. + * @return This builder for chaining. + */ + public Builder setMinDistance(float value) { + + minDistance_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * float min_distance = 2; + * @return This builder for chaining. + */ + public Builder clearMinDistance() { + bitField0_ = (bitField0_ & ~0x00000002); + minDistance_ = 0F; + onChanged(); + return this; + } + + private float maxDistance_ ; + /** + * float max_distance = 3; + * @return The maxDistance. + */ + @java.lang.Override + public float getMaxDistance() { + return maxDistance_; + } + /** + * float max_distance = 3; + * @param value The maxDistance to set. + * @return This builder for chaining. + */ + public Builder setMaxDistance(float value) { + + maxDistance_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * float max_distance = 3; + * @return This builder for chaining. + */ + public Builder clearMaxDistance() { + bitField0_ = (bitField0_ & ~0x00000004); + maxDistance_ = 0F; + onChanged(); + return this; + } + + private long numberOfObjects_ ; + /** + * int64 number_of_objects = 4; + * @return The numberOfObjects. + */ + @java.lang.Override + public long getNumberOfObjects() { + return numberOfObjects_; + } + /** + * int64 number_of_objects = 4; + * @param value The numberOfObjects to set. + * @return This builder for chaining. + */ + public Builder setNumberOfObjects(long value) { + + numberOfObjects_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * int64 number_of_objects = 4; + * @return This builder for chaining. + */ + public Builder clearNumberOfObjects() { + bitField0_ = (bitField0_ & ~0x00000008); + numberOfObjects_ = 0L; + onChanged(); + return this; + } + + private java.util.List objects_ = + java.util.Collections.emptyList(); + private void ensureObjectsIsMutable() { + if (!((bitField0_ & 0x00000010) != 0)) { + objects_ = new java.util.ArrayList(objects_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder> objectsBuilder_; + + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public java.util.List getObjectsList() { + if (objectsBuilder_ == null) { + return java.util.Collections.unmodifiableList(objects_); + } else { + return objectsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public int getObjectsCount() { + if (objectsBuilder_ == null) { + return objects_.size(); + } else { + return objectsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getObjects(int index) { + if (objectsBuilder_ == null) { + return objects_.get(index); + } else { + return objectsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder setObjects( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (objectsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectsIsMutable(); + objects_.set(index, value); + onChanged(); + } else { + objectsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder setObjects( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + objects_.set(index, builderForValue.build()); + onChanged(); + } else { + objectsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder addObjects(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (objectsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectsIsMutable(); + objects_.add(value); + onChanged(); + } else { + objectsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder addObjects( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult value) { + if (objectsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureObjectsIsMutable(); + objects_.add(index, value); + onChanged(); + } else { + objectsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder addObjects( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + objects_.add(builderForValue.build()); + onChanged(); + } else { + objectsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder addObjects( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder builderForValue) { + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + objects_.add(index, builderForValue.build()); + onChanged(); + } else { + objectsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder addAllObjects( + java.lang.Iterable values) { + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, objects_); + onChanged(); + } else { + objectsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder clearObjects() { + if (objectsBuilder_ == null) { + objects_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + objectsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public Builder removeObjects(int index) { + if (objectsBuilder_ == null) { + ensureObjectsIsMutable(); + objects_.remove(index); + onChanged(); + } else { + objectsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder getObjectsBuilder( + int index) { + return getObjectsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder getObjectsOrBuilder( + int index) { + if (objectsBuilder_ == null) { + return objects_.get(index); } else { + return objectsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public java.util.List + getObjectsOrBuilderList() { + if (objectsBuilder_ != null) { + return objectsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(objects_); + } + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder addObjectsBuilder() { + return getObjectsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder addObjectsBuilder( + int index) { + return getObjectsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.SearchResult objects = 5; + */ + public java.util.List + getObjectsBuilderList() { + return getObjectsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder> + getObjectsFieldBuilder() { + if (objectsBuilder_ == null) { + objectsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder>( + objects_, + ((bitField0_ & 0x00000010) != 0), + getParentForChildren(), + isClean()); + objects_ = null; + } + return objectsBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply rerank_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder> rerankBuilder_; + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return Whether the rerank field is set. + */ + public boolean hasRerank() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + * @return The rerank. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply getRerank() { + if (rerankBuilder_ == null) { + return rerank_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; + } else { + return rerankBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public Builder setRerank(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply value) { + if (rerankBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + rerank_ = value; + } else { + rerankBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public Builder setRerank( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder builderForValue) { + if (rerankBuilder_ == null) { + rerank_ = builderForValue.build(); + } else { + rerankBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public Builder mergeRerank(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply value) { + if (rerankBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0) && + rerank_ != null && + rerank_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance()) { + getRerankBuilder().mergeFrom(value); + } else { + rerank_ = value; + } + } else { + rerankBuilder_.mergeFrom(value); + } + if (rerank_ != null) { + bitField0_ |= 0x00000020; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public Builder clearRerank() { + bitField0_ = (bitField0_ & ~0x00000020); + rerank_ = null; + if (rerankBuilder_ != null) { + rerankBuilder_.dispose(); + rerankBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder getRerankBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getRerankFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder getRerankOrBuilder() { + if (rerankBuilder_ != null) { + return rerankBuilder_.getMessageOrBuilder(); + } else { + return rerank_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.getDefaultInstance() : rerank_; + } + } + /** + * optional .weaviate.v1.RerankReply rerank = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder> + getRerankFieldBuilder() { + if (rerankBuilder_ == null) { + rerankBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RerankReplyOrBuilder>( + getRerank(), + getParentForChildren(), + isClean()); + rerank_ = null; + } + return rerankBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply generative_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder> generativeBuilder_; + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return Whether the generative field is set. + */ + @java.lang.Deprecated public boolean hasGenerative() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + * @deprecated weaviate.v1.GroupByResult.generative is deprecated. + * See v1/search_get.proto;l=130 + * @return The generative. + */ + @java.lang.Deprecated public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply getGenerative() { + if (generativeBuilder_ == null) { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; + } else { + return generativeBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public Builder setGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply value) { + if (generativeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + generative_ = value; + } else { + generativeBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public Builder setGenerative( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder builderForValue) { + if (generativeBuilder_ == null) { + generative_ = builderForValue.build(); + } else { + generativeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public Builder mergeGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply value) { + if (generativeBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0) && + generative_ != null && + generative_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance()) { + getGenerativeBuilder().mergeFrom(value); + } else { + generative_ = value; + } + } else { + generativeBuilder_.mergeFrom(value); + } + if (generative_ != null) { + bitField0_ |= 0x00000040; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public Builder clearGenerative() { + bitField0_ = (bitField0_ & ~0x00000040); + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder getGenerativeBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getGenerativeFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + @java.lang.Deprecated public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder getGenerativeOrBuilder() { + if (generativeBuilder_ != null) { + return generativeBuilder_.getMessageOrBuilder(); + } else { + return generative_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.getDefaultInstance() : generative_; + } + } + /** + * optional .weaviate.v1.GenerativeReply generative = 7 [deprecated = true]; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder> + getGenerativeFieldBuilder() { + if (generativeBuilder_ == null) { + generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReply.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeReplyOrBuilder>( + getGenerative(), + getParentForChildren(), + isClean()); + generative_ = null; + } + return generativeBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generativeResult_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeResultBuilder_; + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return Whether the generativeResult field is set. + */ + public boolean hasGenerativeResult() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + * @return The generativeResult. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerativeResult() { + if (generativeResultBuilder_ == null) { + return generativeResult_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; + } else { + return generativeResultBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public Builder setGenerativeResult(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeResultBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + generativeResult_ = value; + } else { + generativeResultBuilder_.setMessage(value); + } + bitField0_ |= 0x00000080; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public Builder setGenerativeResult( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { + if (generativeResultBuilder_ == null) { + generativeResult_ = builderForValue.build(); + } else { + generativeResultBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000080; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public Builder mergeGenerativeResult(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeResultBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0) && + generativeResult_ != null && + generativeResult_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { + getGenerativeResultBuilder().mergeFrom(value); + } else { + generativeResult_ = value; + } + } else { + generativeResultBuilder_.mergeFrom(value); + } + if (generativeResult_ != null) { + bitField0_ |= 0x00000080; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public Builder clearGenerativeResult() { + bitField0_ = (bitField0_ & ~0x00000080); + generativeResult_ = null; + if (generativeResultBuilder_ != null) { + generativeResultBuilder_.dispose(); + generativeResultBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeResultBuilder() { + bitField0_ |= 0x00000080; + onChanged(); + return getGenerativeResultFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeResultOrBuilder() { + if (generativeResultBuilder_ != null) { + return generativeResultBuilder_.getMessageOrBuilder(); + } else { + return generativeResult_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generativeResult_; + } + } + /** + * optional .weaviate.v1.GenerativeResult generative_result = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> + getGenerativeResultFieldBuilder() { + if (generativeResultBuilder_ == null) { + generativeResultBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder>( + getGenerativeResult(), + getParentForChildren(), + isClean()); + generativeResult_ = null; + } + return generativeResultBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.GroupByResult) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.GroupByResult) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GroupByResult parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.GroupByResult getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SearchResultOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.SearchResult) + com.google.protobuf.MessageOrBuilder { + + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return Whether the properties field is set. + */ + boolean hasProperties(); + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return The properties. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties(); + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder(); + + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return Whether the metadata field is set. + */ + boolean hasMetadata(); + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return The metadata. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata(); + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder(); + + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return Whether the generative field is set. + */ + boolean hasGenerative(); + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return The generative. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerative(); + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder(); + } + /** + * Protobuf type {@code weaviate.v1.SearchResult} + */ + public static final class SearchResult extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.SearchResult) + SearchResultOrBuilder { + private static final long serialVersionUID = 0L; + // Use SearchResult.newBuilder() to construct. + private SearchResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SearchResult() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SearchResult(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder.class); + } + + private int bitField0_; + public static final int PROPERTIES_FIELD_NUMBER = 1; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult properties_; + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return Whether the properties field is set. + */ + @java.lang.Override + public boolean hasProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return The properties. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder() { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; + } + + public static final int METADATA_FIELD_NUMBER = 2; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult metadata_; + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return Whether the metadata field is set. + */ + @java.lang.Override + public boolean hasMetadata() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return The metadata. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + + public static final int GENERATIVE_FIELD_NUMBER = 3; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generative_; + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return Whether the generative field is set. + */ + @java.lang.Override + public boolean hasGenerative() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return The generative. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerative() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder() { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getProperties()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getMetadata()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(3, getGenerative()); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getProperties()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getMetadata()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getGenerative()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult) obj; + + if (hasProperties() != other.hasProperties()) return false; + if (hasProperties()) { + if (!getProperties() + .equals(other.getProperties())) return false; + } + if (hasMetadata() != other.hasMetadata()) return false; + if (hasMetadata()) { + if (!getMetadata() + .equals(other.getMetadata())) return false; + } + if (hasGenerative() != other.hasGenerative()) return false; + if (hasGenerative()) { + if (!getGenerative() + .equals(other.getGenerative())) return false; + } + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasProperties()) { + hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getProperties().hashCode(); + } + if (hasMetadata()) { + hash = (37 * hash) + METADATA_FIELD_NUMBER; + hash = (53 * hash) + getMetadata().hashCode(); + } + if (hasGenerative()) { + hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; + hash = (53 * hash) + getGenerative().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.SearchResult} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.SearchResult) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResultOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPropertiesFieldBuilder(); + getMetadataFieldBuilder(); + getGenerativeFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_SearchResult_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult result) { + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.properties_ = propertiesBuilder_ == null + ? properties_ + : propertiesBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.metadata_ = metadataBuilder_ == null + ? metadata_ + : metadataBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.generative_ = generativeBuilder_ == null + ? generative_ + : generativeBuilder_.build(); + to_bitField0_ |= 0x00000004; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult.getDefaultInstance()) return this; + if (other.hasProperties()) { + mergeProperties(other.getProperties()); + } + if (other.hasMetadata()) { + mergeMetadata(other.getMetadata()); + } + if (other.hasGenerative()) { + mergeGenerative(other.getGenerative()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + input.readMessage( + getPropertiesFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 18: { + input.readMessage( + getMetadataFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000002; + break; + } // case 18 + case 26: { + input.readMessage( + getGenerativeFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000004; + break; + } // case 26 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult properties_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder> propertiesBuilder_; + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return Whether the properties field is set. + */ + public boolean hasProperties() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + * @return The properties. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties() { + if (propertiesBuilder_ == null) { + return properties_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; + } else { + return propertiesBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder setProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + properties_ = value; + } else { + propertiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder setProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { + if (propertiesBuilder_ == null) { + properties_ = builderForValue.build(); + } else { + propertiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder mergeProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult value) { + if (propertiesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + properties_ != null && + properties_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()) { + getPropertiesBuilder().mergeFrom(value); + } else { + properties_ = value; + } + } else { + propertiesBuilder_.mergeFrom(value); + } + if (properties_ != null) { + bitField0_ |= 0x00000001; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder clearProperties() { + bitField0_ = (bitField0_ & ~0x00000001); + properties_ = null; + if (propertiesBuilder_ != null) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder getPropertiesBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getPropertiesFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder() { + if (propertiesBuilder_ != null) { + return propertiesBuilder_.getMessageOrBuilder(); + } else { + return properties_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance() : properties_; + } + } + /** + * .weaviate.v1.PropertiesResult properties = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder> + getPropertiesFieldBuilder() { + if (propertiesBuilder_ == null) { + propertiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder>( + getProperties(), + getParentForChildren(), + isClean()); + properties_ = null; + } + return propertiesBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult metadata_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder> metadataBuilder_; + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return Whether the metadata field is set. + */ + public boolean hasMetadata() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + * @return The metadata. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata() { + if (metadataBuilder_ == null) { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } else { + return metadataBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult value) { + if (metadataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + metadata_ = value; + } else { + metadataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public Builder setMetadata( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder builderForValue) { + if (metadataBuilder_ == null) { + metadata_ = builderForValue.build(); + } else { + metadataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult value) { + if (metadataBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + metadata_ != null && + metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) { + getMetadataBuilder().mergeFrom(value); + } else { + metadata_ = value; + } + } else { + metadataBuilder_.mergeFrom(value); + } + if (metadata_ != null) { + bitField0_ |= 0x00000002; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public Builder clearMetadata() { + bitField0_ = (bitField0_ & ~0x00000002); + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder getMetadataBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getMetadataFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { + if (metadataBuilder_ != null) { + return metadataBuilder_.getMessageOrBuilder(); + } else { + return metadata_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + } + /** + * .weaviate.v1.MetadataResult metadata = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder> + getMetadataFieldBuilder() { + if (metadataBuilder_ == null) { + metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder>( + getMetadata(), + getParentForChildren(), + isClean()); + metadata_ = null; + } + return metadataBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult generative_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> generativeBuilder_; + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return Whether the generative field is set. + */ + public boolean hasGenerative() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + * @return The generative. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult getGenerative() { + if (generativeBuilder_ == null) { + return generative_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; + } else { + return generativeBuilder_.getMessage(); + } + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public Builder setGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + generative_ = value; + } else { + generativeBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public Builder setGenerative( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder builderForValue) { + if (generativeBuilder_ == null) { + generative_ = builderForValue.build(); + } else { + generativeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public Builder mergeGenerative(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult value) { + if (generativeBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + generative_ != null && + generative_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance()) { + getGenerativeBuilder().mergeFrom(value); + } else { + generative_ = value; + } + } else { + generativeBuilder_.mergeFrom(value); + } + if (generative_ != null) { + bitField0_ |= 0x00000004; + onChanged(); + } + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public Builder clearGenerative() { + bitField0_ = (bitField0_ & ~0x00000004); + generative_ = null; + if (generativeBuilder_ != null) { + generativeBuilder_.dispose(); + generativeBuilder_ = null; + } + onChanged(); + return this; + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder getGenerativeBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getGenerativeFieldBuilder().getBuilder(); + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder getGenerativeOrBuilder() { + if (generativeBuilder_ != null) { + return generativeBuilder_.getMessageOrBuilder(); + } else { + return generative_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.getDefaultInstance() : generative_; + } + } + /** + * optional .weaviate.v1.GenerativeResult generative = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder> + getGenerativeFieldBuilder() { + if (generativeBuilder_ == null) { + generativeBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.GenerativeResultOrBuilder>( + getGenerative(), + getParentForChildren(), + isClean()); + generative_ = null; + } + return generativeBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.SearchResult) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.SearchResult) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SearchResult parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.SearchResult getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface MetadataResultOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.MetadataResult) + com.google.protobuf.MessageOrBuilder { + + /** + * string id = 1; + * @return The id. + */ + java.lang.String getId(); + /** + * string id = 1; + * @return The bytes for id. + */ + com.google.protobuf.ByteString + getIdBytes(); + + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return A list containing the vector. + */ + @java.lang.Deprecated java.util.List getVectorList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return The count of vector. + */ + @java.lang.Deprecated int getVectorCount(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated float getVector(int index); + + /** + * int64 creation_time_unix = 3; + * @return The creationTimeUnix. + */ + long getCreationTimeUnix(); + + /** + * bool creation_time_unix_present = 4; + * @return The creationTimeUnixPresent. + */ + boolean getCreationTimeUnixPresent(); + + /** + * int64 last_update_time_unix = 5; + * @return The lastUpdateTimeUnix. + */ + long getLastUpdateTimeUnix(); + + /** + * bool last_update_time_unix_present = 6; + * @return The lastUpdateTimeUnixPresent. + */ + boolean getLastUpdateTimeUnixPresent(); + + /** + * float distance = 7; + * @return The distance. + */ + float getDistance(); + + /** + * bool distance_present = 8; + * @return The distancePresent. + */ + boolean getDistancePresent(); + + /** + * float certainty = 9; + * @return The certainty. + */ + float getCertainty(); + + /** + * bool certainty_present = 10; + * @return The certaintyPresent. + */ + boolean getCertaintyPresent(); + + /** + * float score = 11; + * @return The score. + */ + float getScore(); + + /** + * bool score_present = 12; + * @return The scorePresent. + */ + boolean getScorePresent(); + + /** + * string explain_score = 13; + * @return The explainScore. + */ + java.lang.String getExplainScore(); + /** + * string explain_score = 13; + * @return The bytes for explainScore. + */ + com.google.protobuf.ByteString + getExplainScoreBytes(); + + /** + * bool explain_score_present = 14; + * @return The explainScorePresent. + */ + boolean getExplainScorePresent(); + + /** + * optional bool is_consistent = 15; + * @return Whether the isConsistent field is set. + */ + boolean hasIsConsistent(); + /** + * optional bool is_consistent = 15; + * @return The isConsistent. + */ + boolean getIsConsistent(); + + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The generative. + */ + @java.lang.Deprecated java.lang.String getGenerative(); + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The bytes for generative. + */ + @java.lang.Deprecated com.google.protobuf.ByteString + getGenerativeBytes(); + + /** + * bool generative_present = 17 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. + * See v1/search_get.proto;l=159 + * @return The generativePresent. + */ + @java.lang.Deprecated boolean getGenerativePresent(); + + /** + * bool is_consistent_present = 18; + * @return The isConsistentPresent. + */ + boolean getIsConsistentPresent(); + + /** + * bytes vector_bytes = 19; + * @return The vectorBytes. + */ + com.google.protobuf.ByteString getVectorBytes(); + + /** + * bytes id_as_bytes = 20; + * @return The idAsBytes. + */ + com.google.protobuf.ByteString getIdAsBytes(); + + /** + * double rerank_score = 21; + * @return The rerankScore. + */ + double getRerankScore(); + + /** + * bool rerank_score_present = 22; + * @return The rerankScorePresent. + */ + boolean getRerankScorePresent(); + + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + java.util.List + getVectorsList(); + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index); + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + int getVectorsCount(); + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + java.util.List + getVectorsOrBuilderList(); + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index); + } + /** + * Protobuf type {@code weaviate.v1.MetadataResult} + */ + public static final class MetadataResult extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.MetadataResult) + MetadataResultOrBuilder { + private static final long serialVersionUID = 0L; + // Use MetadataResult.newBuilder() to construct. + private MetadataResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private MetadataResult() { + id_ = ""; + vector_ = emptyFloatList(); + explainScore_ = ""; + generative_ = ""; + vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + idAsBytes_ = com.google.protobuf.ByteString.EMPTY; + vectors_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new MetadataResult(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder.class); + } + + private int bitField0_; + public static final int ID_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object id_ = ""; + /** + * string id = 1; + * @return The id. + */ + @java.lang.Override + public java.lang.String getId() { + java.lang.Object ref = id_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + id_ = s; + return s; + } + } + /** + * string id = 1; + * @return The bytes for id. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getIdBytes() { + java.lang.Object ref = id_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + id_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VECTOR_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private com.google.protobuf.Internal.FloatList vector_ = + emptyFloatList(); + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return A list containing the vector. + */ + @java.lang.Override + @java.lang.Deprecated public java.util.List + getVectorList() { + return vector_; + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return The count of vector. + */ + @java.lang.Deprecated public int getVectorCount() { + return vector_.size(); + } + /** + *
+     * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+     * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated public float getVector(int index) { + return vector_.getFloat(index); + } + private int vectorMemoizedSerializedSize = -1; + + public static final int CREATION_TIME_UNIX_FIELD_NUMBER = 3; + private long creationTimeUnix_ = 0L; + /** + * int64 creation_time_unix = 3; + * @return The creationTimeUnix. + */ + @java.lang.Override + public long getCreationTimeUnix() { + return creationTimeUnix_; + } + + public static final int CREATION_TIME_UNIX_PRESENT_FIELD_NUMBER = 4; + private boolean creationTimeUnixPresent_ = false; + /** + * bool creation_time_unix_present = 4; + * @return The creationTimeUnixPresent. + */ + @java.lang.Override + public boolean getCreationTimeUnixPresent() { + return creationTimeUnixPresent_; + } + + public static final int LAST_UPDATE_TIME_UNIX_FIELD_NUMBER = 5; + private long lastUpdateTimeUnix_ = 0L; + /** + * int64 last_update_time_unix = 5; + * @return The lastUpdateTimeUnix. + */ + @java.lang.Override + public long getLastUpdateTimeUnix() { + return lastUpdateTimeUnix_; + } + + public static final int LAST_UPDATE_TIME_UNIX_PRESENT_FIELD_NUMBER = 6; + private boolean lastUpdateTimeUnixPresent_ = false; + /** + * bool last_update_time_unix_present = 6; + * @return The lastUpdateTimeUnixPresent. + */ + @java.lang.Override + public boolean getLastUpdateTimeUnixPresent() { + return lastUpdateTimeUnixPresent_; + } + + public static final int DISTANCE_FIELD_NUMBER = 7; + private float distance_ = 0F; + /** + * float distance = 7; + * @return The distance. + */ + @java.lang.Override + public float getDistance() { + return distance_; + } + + public static final int DISTANCE_PRESENT_FIELD_NUMBER = 8; + private boolean distancePresent_ = false; + /** + * bool distance_present = 8; + * @return The distancePresent. + */ + @java.lang.Override + public boolean getDistancePresent() { + return distancePresent_; + } + + public static final int CERTAINTY_FIELD_NUMBER = 9; + private float certainty_ = 0F; + /** + * float certainty = 9; + * @return The certainty. + */ + @java.lang.Override + public float getCertainty() { + return certainty_; + } + + public static final int CERTAINTY_PRESENT_FIELD_NUMBER = 10; + private boolean certaintyPresent_ = false; + /** + * bool certainty_present = 10; + * @return The certaintyPresent. + */ + @java.lang.Override + public boolean getCertaintyPresent() { + return certaintyPresent_; + } + + public static final int SCORE_FIELD_NUMBER = 11; + private float score_ = 0F; + /** + * float score = 11; + * @return The score. + */ + @java.lang.Override + public float getScore() { + return score_; + } + + public static final int SCORE_PRESENT_FIELD_NUMBER = 12; + private boolean scorePresent_ = false; + /** + * bool score_present = 12; + * @return The scorePresent. + */ + @java.lang.Override + public boolean getScorePresent() { + return scorePresent_; + } + + public static final int EXPLAIN_SCORE_FIELD_NUMBER = 13; + @SuppressWarnings("serial") + private volatile java.lang.Object explainScore_ = ""; + /** + * string explain_score = 13; + * @return The explainScore. + */ + @java.lang.Override + public java.lang.String getExplainScore() { + java.lang.Object ref = explainScore_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + explainScore_ = s; + return s; + } + } + /** + * string explain_score = 13; + * @return The bytes for explainScore. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getExplainScoreBytes() { + java.lang.Object ref = explainScore_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + explainScore_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int EXPLAIN_SCORE_PRESENT_FIELD_NUMBER = 14; + private boolean explainScorePresent_ = false; + /** + * bool explain_score_present = 14; + * @return The explainScorePresent. + */ + @java.lang.Override + public boolean getExplainScorePresent() { + return explainScorePresent_; + } + + public static final int IS_CONSISTENT_FIELD_NUMBER = 15; + private boolean isConsistent_ = false; + /** + * optional bool is_consistent = 15; + * @return Whether the isConsistent field is set. + */ + @java.lang.Override + public boolean hasIsConsistent() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional bool is_consistent = 15; + * @return The isConsistent. + */ + @java.lang.Override + public boolean getIsConsistent() { + return isConsistent_; + } + + public static final int GENERATIVE_FIELD_NUMBER = 16; + @SuppressWarnings("serial") + private volatile java.lang.Object generative_ = ""; + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The generative. + */ + @java.lang.Override + @java.lang.Deprecated public java.lang.String getGenerative() { + java.lang.Object ref = generative_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + generative_ = s; + return s; + } + } + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The bytes for generative. + */ + @java.lang.Override + @java.lang.Deprecated public com.google.protobuf.ByteString + getGenerativeBytes() { + java.lang.Object ref = generative_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + generative_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int GENERATIVE_PRESENT_FIELD_NUMBER = 17; + private boolean generativePresent_ = false; + /** + * bool generative_present = 17 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. + * See v1/search_get.proto;l=159 + * @return The generativePresent. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getGenerativePresent() { + return generativePresent_; + } + + public static final int IS_CONSISTENT_PRESENT_FIELD_NUMBER = 18; + private boolean isConsistentPresent_ = false; + /** + * bool is_consistent_present = 18; + * @return The isConsistentPresent. + */ + @java.lang.Override + public boolean getIsConsistentPresent() { + return isConsistentPresent_; + } + + public static final int VECTOR_BYTES_FIELD_NUMBER = 19; + private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes vector_bytes = 19; + * @return The vectorBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getVectorBytes() { + return vectorBytes_; + } + + public static final int ID_AS_BYTES_FIELD_NUMBER = 20; + private com.google.protobuf.ByteString idAsBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes id_as_bytes = 20; + * @return The idAsBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getIdAsBytes() { + return idAsBytes_; + } + + public static final int RERANK_SCORE_FIELD_NUMBER = 21; + private double rerankScore_ = 0D; + /** + * double rerank_score = 21; + * @return The rerankScore. + */ + @java.lang.Override + public double getRerankScore() { + return rerankScore_; + } + + public static final int RERANK_SCORE_PRESENT_FIELD_NUMBER = 22; + private boolean rerankScorePresent_ = false; + /** + * bool rerank_score_present = 22; + * @return The rerankScorePresent. + */ + @java.lang.Override + public boolean getRerankScorePresent() { + return rerankScorePresent_; + } + + public static final int VECTORS_FIELD_NUMBER = 23; + @SuppressWarnings("serial") + private java.util.List vectors_; + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public java.util.List getVectorsList() { + return vectors_; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public java.util.List + getVectorsOrBuilderList() { + return vectors_; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public int getVectorsCount() { + return vectors_.size(); + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) { + return vectors_.get(index); + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index) { + return vectors_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(id_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, id_); + } + if (getVectorList().size() > 0) { + output.writeUInt32NoTag(18); + output.writeUInt32NoTag(vectorMemoizedSerializedSize); + } + for (int i = 0; i < vector_.size(); i++) { + output.writeFloatNoTag(vector_.getFloat(i)); + } + if (creationTimeUnix_ != 0L) { + output.writeInt64(3, creationTimeUnix_); + } + if (creationTimeUnixPresent_ != false) { + output.writeBool(4, creationTimeUnixPresent_); + } + if (lastUpdateTimeUnix_ != 0L) { + output.writeInt64(5, lastUpdateTimeUnix_); + } + if (lastUpdateTimeUnixPresent_ != false) { + output.writeBool(6, lastUpdateTimeUnixPresent_); + } + if (java.lang.Float.floatToRawIntBits(distance_) != 0) { + output.writeFloat(7, distance_); + } + if (distancePresent_ != false) { + output.writeBool(8, distancePresent_); + } + if (java.lang.Float.floatToRawIntBits(certainty_) != 0) { + output.writeFloat(9, certainty_); + } + if (certaintyPresent_ != false) { + output.writeBool(10, certaintyPresent_); + } + if (java.lang.Float.floatToRawIntBits(score_) != 0) { + output.writeFloat(11, score_); + } + if (scorePresent_ != false) { + output.writeBool(12, scorePresent_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(explainScore_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 13, explainScore_); + } + if (explainScorePresent_ != false) { + output.writeBool(14, explainScorePresent_); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBool(15, isConsistent_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(generative_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 16, generative_); + } + if (generativePresent_ != false) { + output.writeBool(17, generativePresent_); + } + if (isConsistentPresent_ != false) { + output.writeBool(18, isConsistentPresent_); + } + if (!vectorBytes_.isEmpty()) { + output.writeBytes(19, vectorBytes_); + } + if (!idAsBytes_.isEmpty()) { + output.writeBytes(20, idAsBytes_); + } + if (java.lang.Double.doubleToRawLongBits(rerankScore_) != 0) { + output.writeDouble(21, rerankScore_); + } + if (rerankScorePresent_ != false) { + output.writeBool(22, rerankScorePresent_); + } + for (int i = 0; i < vectors_.size(); i++) { + output.writeMessage(23, vectors_.get(i)); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(id_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, id_); + } + { + int dataSize = 0; + dataSize = 4 * getVectorList().size(); + size += dataSize; + if (!getVectorList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + vectorMemoizedSerializedSize = dataSize; + } + if (creationTimeUnix_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(3, creationTimeUnix_); + } + if (creationTimeUnixPresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(4, creationTimeUnixPresent_); + } + if (lastUpdateTimeUnix_ != 0L) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size(5, lastUpdateTimeUnix_); + } + if (lastUpdateTimeUnixPresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(6, lastUpdateTimeUnixPresent_); + } + if (java.lang.Float.floatToRawIntBits(distance_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(7, distance_); + } + if (distancePresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(8, distancePresent_); + } + if (java.lang.Float.floatToRawIntBits(certainty_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(9, certainty_); + } + if (certaintyPresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(10, certaintyPresent_); + } + if (java.lang.Float.floatToRawIntBits(score_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(11, score_); + } + if (scorePresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(12, scorePresent_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(explainScore_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(13, explainScore_); + } + if (explainScorePresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(14, explainScorePresent_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(15, isConsistent_); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(generative_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(16, generative_); + } + if (generativePresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(17, generativePresent_); + } + if (isConsistentPresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(18, isConsistentPresent_); + } + if (!vectorBytes_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(19, vectorBytes_); + } + if (!idAsBytes_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(20, idAsBytes_); + } + if (java.lang.Double.doubleToRawLongBits(rerankScore_) != 0) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(21, rerankScore_); + } + if (rerankScorePresent_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(22, rerankScorePresent_); + } + for (int i = 0; i < vectors_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(23, vectors_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult) obj; + + if (!getId() + .equals(other.getId())) return false; + if (!getVectorList() + .equals(other.getVectorList())) return false; + if (getCreationTimeUnix() + != other.getCreationTimeUnix()) return false; + if (getCreationTimeUnixPresent() + != other.getCreationTimeUnixPresent()) return false; + if (getLastUpdateTimeUnix() + != other.getLastUpdateTimeUnix()) return false; + if (getLastUpdateTimeUnixPresent() + != other.getLastUpdateTimeUnixPresent()) return false; + if (java.lang.Float.floatToIntBits(getDistance()) + != java.lang.Float.floatToIntBits( + other.getDistance())) return false; + if (getDistancePresent() + != other.getDistancePresent()) return false; + if (java.lang.Float.floatToIntBits(getCertainty()) + != java.lang.Float.floatToIntBits( + other.getCertainty())) return false; + if (getCertaintyPresent() + != other.getCertaintyPresent()) return false; + if (java.lang.Float.floatToIntBits(getScore()) + != java.lang.Float.floatToIntBits( + other.getScore())) return false; + if (getScorePresent() + != other.getScorePresent()) return false; + if (!getExplainScore() + .equals(other.getExplainScore())) return false; + if (getExplainScorePresent() + != other.getExplainScorePresent()) return false; + if (hasIsConsistent() != other.hasIsConsistent()) return false; + if (hasIsConsistent()) { + if (getIsConsistent() + != other.getIsConsistent()) return false; + } + if (!getGenerative() + .equals(other.getGenerative())) return false; + if (getGenerativePresent() + != other.getGenerativePresent()) return false; + if (getIsConsistentPresent() + != other.getIsConsistentPresent()) return false; + if (!getVectorBytes() + .equals(other.getVectorBytes())) return false; + if (!getIdAsBytes() + .equals(other.getIdAsBytes())) return false; + if (java.lang.Double.doubleToLongBits(getRerankScore()) + != java.lang.Double.doubleToLongBits( + other.getRerankScore())) return false; + if (getRerankScorePresent() + != other.getRerankScorePresent()) return false; + if (!getVectorsList() + .equals(other.getVectorsList())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + ID_FIELD_NUMBER; + hash = (53 * hash) + getId().hashCode(); + if (getVectorCount() > 0) { + hash = (37 * hash) + VECTOR_FIELD_NUMBER; + hash = (53 * hash) + getVectorList().hashCode(); + } + hash = (37 * hash) + CREATION_TIME_UNIX_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getCreationTimeUnix()); + hash = (37 * hash) + CREATION_TIME_UNIX_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCreationTimeUnixPresent()); + hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getLastUpdateTimeUnix()); + hash = (37 * hash) + LAST_UPDATE_TIME_UNIX_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getLastUpdateTimeUnixPresent()); + hash = (37 * hash) + DISTANCE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getDistance()); + hash = (37 * hash) + DISTANCE_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getDistancePresent()); + hash = (37 * hash) + CERTAINTY_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getCertainty()); + hash = (37 * hash) + CERTAINTY_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCertaintyPresent()); + hash = (37 * hash) + SCORE_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getScore()); + hash = (37 * hash) + SCORE_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getScorePresent()); + hash = (37 * hash) + EXPLAIN_SCORE_FIELD_NUMBER; + hash = (53 * hash) + getExplainScore().hashCode(); + hash = (37 * hash) + EXPLAIN_SCORE_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getExplainScorePresent()); + if (hasIsConsistent()) { + hash = (37 * hash) + IS_CONSISTENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsConsistent()); + } + hash = (37 * hash) + GENERATIVE_FIELD_NUMBER; + hash = (53 * hash) + getGenerative().hashCode(); + hash = (37 * hash) + GENERATIVE_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getGenerativePresent()); + hash = (37 * hash) + IS_CONSISTENT_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIsConsistentPresent()); + hash = (37 * hash) + VECTOR_BYTES_FIELD_NUMBER; + hash = (53 * hash) + getVectorBytes().hashCode(); + hash = (37 * hash) + ID_AS_BYTES_FIELD_NUMBER; + hash = (53 * hash) + getIdAsBytes().hashCode(); + hash = (37 * hash) + RERANK_SCORE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getRerankScore())); + hash = (37 * hash) + RERANK_SCORE_PRESENT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getRerankScorePresent()); + if (getVectorsCount() > 0) { + hash = (37 * hash) + VECTORS_FIELD_NUMBER; + hash = (53 * hash) + getVectorsList().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.MetadataResult} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.MetadataResult) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + id_ = ""; + vector_ = emptyFloatList(); + creationTimeUnix_ = 0L; + creationTimeUnixPresent_ = false; + lastUpdateTimeUnix_ = 0L; + lastUpdateTimeUnixPresent_ = false; + distance_ = 0F; + distancePresent_ = false; + certainty_ = 0F; + certaintyPresent_ = false; + score_ = 0F; + scorePresent_ = false; + explainScore_ = ""; + explainScorePresent_ = false; + isConsistent_ = false; + generative_ = ""; + generativePresent_ = false; + isConsistentPresent_ = false; + vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + idAsBytes_ = com.google.protobuf.ByteString.EMPTY; + rerankScore_ = 0D; + rerankScorePresent_ = false; + if (vectorsBuilder_ == null) { + vectors_ = java.util.Collections.emptyList(); + } else { + vectors_ = null; + vectorsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00400000); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_MetadataResult_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult result) { + if (vectorsBuilder_ == null) { + if (((bitField0_ & 0x00400000) != 0)) { + vectors_ = java.util.Collections.unmodifiableList(vectors_); + bitField0_ = (bitField0_ & ~0x00400000); + } + result.vectors_ = vectors_; + } else { + result.vectors_ = vectorsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.id_ = id_; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + vector_.makeImmutable(); + result.vector_ = vector_; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.creationTimeUnix_ = creationTimeUnix_; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.creationTimeUnixPresent_ = creationTimeUnixPresent_; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.lastUpdateTimeUnix_ = lastUpdateTimeUnix_; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.lastUpdateTimeUnixPresent_ = lastUpdateTimeUnixPresent_; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.distance_ = distance_; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + result.distancePresent_ = distancePresent_; + } + if (((from_bitField0_ & 0x00000100) != 0)) { + result.certainty_ = certainty_; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + result.certaintyPresent_ = certaintyPresent_; + } + if (((from_bitField0_ & 0x00000400) != 0)) { + result.score_ = score_; + } + if (((from_bitField0_ & 0x00000800) != 0)) { + result.scorePresent_ = scorePresent_; + } + if (((from_bitField0_ & 0x00001000) != 0)) { + result.explainScore_ = explainScore_; + } + if (((from_bitField0_ & 0x00002000) != 0)) { + result.explainScorePresent_ = explainScorePresent_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00004000) != 0)) { + result.isConsistent_ = isConsistent_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00008000) != 0)) { + result.generative_ = generative_; + } + if (((from_bitField0_ & 0x00010000) != 0)) { + result.generativePresent_ = generativePresent_; + } + if (((from_bitField0_ & 0x00020000) != 0)) { + result.isConsistentPresent_ = isConsistentPresent_; + } + if (((from_bitField0_ & 0x00040000) != 0)) { + result.vectorBytes_ = vectorBytes_; + } + if (((from_bitField0_ & 0x00080000) != 0)) { + result.idAsBytes_ = idAsBytes_; + } + if (((from_bitField0_ & 0x00100000) != 0)) { + result.rerankScore_ = rerankScore_; + } + if (((from_bitField0_ & 0x00200000) != 0)) { + result.rerankScorePresent_ = rerankScorePresent_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) return this; + if (!other.getId().isEmpty()) { + id_ = other.id_; + bitField0_ |= 0x00000001; + onChanged(); + } + if (!other.vector_.isEmpty()) { + if (vector_.isEmpty()) { + vector_ = other.vector_; + vector_.makeImmutable(); + bitField0_ |= 0x00000002; + } else { + ensureVectorIsMutable(); + vector_.addAll(other.vector_); + } + onChanged(); + } + if (other.getCreationTimeUnix() != 0L) { + setCreationTimeUnix(other.getCreationTimeUnix()); + } + if (other.getCreationTimeUnixPresent() != false) { + setCreationTimeUnixPresent(other.getCreationTimeUnixPresent()); + } + if (other.getLastUpdateTimeUnix() != 0L) { + setLastUpdateTimeUnix(other.getLastUpdateTimeUnix()); + } + if (other.getLastUpdateTimeUnixPresent() != false) { + setLastUpdateTimeUnixPresent(other.getLastUpdateTimeUnixPresent()); + } + if (other.getDistance() != 0F) { + setDistance(other.getDistance()); + } + if (other.getDistancePresent() != false) { + setDistancePresent(other.getDistancePresent()); + } + if (other.getCertainty() != 0F) { + setCertainty(other.getCertainty()); + } + if (other.getCertaintyPresent() != false) { + setCertaintyPresent(other.getCertaintyPresent()); + } + if (other.getScore() != 0F) { + setScore(other.getScore()); + } + if (other.getScorePresent() != false) { + setScorePresent(other.getScorePresent()); + } + if (!other.getExplainScore().isEmpty()) { + explainScore_ = other.explainScore_; + bitField0_ |= 0x00001000; + onChanged(); + } + if (other.getExplainScorePresent() != false) { + setExplainScorePresent(other.getExplainScorePresent()); + } + if (other.hasIsConsistent()) { + setIsConsistent(other.getIsConsistent()); + } + if (!other.getGenerative().isEmpty()) { + generative_ = other.generative_; + bitField0_ |= 0x00008000; + onChanged(); + } + if (other.getGenerativePresent() != false) { + setGenerativePresent(other.getGenerativePresent()); + } + if (other.getIsConsistentPresent() != false) { + setIsConsistentPresent(other.getIsConsistentPresent()); + } + if (other.getVectorBytes() != com.google.protobuf.ByteString.EMPTY) { + setVectorBytes(other.getVectorBytes()); + } + if (other.getIdAsBytes() != com.google.protobuf.ByteString.EMPTY) { + setIdAsBytes(other.getIdAsBytes()); + } + if (other.getRerankScore() != 0D) { + setRerankScore(other.getRerankScore()); + } + if (other.getRerankScorePresent() != false) { + setRerankScorePresent(other.getRerankScorePresent()); + } + if (vectorsBuilder_ == null) { + if (!other.vectors_.isEmpty()) { + if (vectors_.isEmpty()) { + vectors_ = other.vectors_; + bitField0_ = (bitField0_ & ~0x00400000); + } else { + ensureVectorsIsMutable(); + vectors_.addAll(other.vectors_); + } + onChanged(); + } + } else { + if (!other.vectors_.isEmpty()) { + if (vectorsBuilder_.isEmpty()) { + vectorsBuilder_.dispose(); + vectorsBuilder_ = null; + vectors_ = other.vectors_; + bitField0_ = (bitField0_ & ~0x00400000); + vectorsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getVectorsFieldBuilder() : null; + } else { + vectorsBuilder_.addAllMessages(other.vectors_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + id_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + case 21: { + float v = input.readFloat(); + ensureVectorIsMutable(); + vector_.addFloat(v); + break; + } // case 21 + case 18: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + int alloc = length > 4096 ? 4096 : length; + ensureVectorIsMutable(alloc / 4); + while (input.getBytesUntilLimit() > 0) { + vector_.addFloat(input.readFloat()); + } + input.popLimit(limit); + break; + } // case 18 + case 24: { + creationTimeUnix_ = input.readInt64(); + bitField0_ |= 0x00000004; + break; + } // case 24 + case 32: { + creationTimeUnixPresent_ = input.readBool(); + bitField0_ |= 0x00000008; + break; + } // case 32 + case 40: { + lastUpdateTimeUnix_ = input.readInt64(); + bitField0_ |= 0x00000010; + break; + } // case 40 + case 48: { + lastUpdateTimeUnixPresent_ = input.readBool(); + bitField0_ |= 0x00000020; + break; + } // case 48 + case 61: { + distance_ = input.readFloat(); + bitField0_ |= 0x00000040; + break; + } // case 61 + case 64: { + distancePresent_ = input.readBool(); + bitField0_ |= 0x00000080; + break; + } // case 64 + case 77: { + certainty_ = input.readFloat(); + bitField0_ |= 0x00000100; + break; + } // case 77 + case 80: { + certaintyPresent_ = input.readBool(); + bitField0_ |= 0x00000200; + break; + } // case 80 + case 93: { + score_ = input.readFloat(); + bitField0_ |= 0x00000400; + break; + } // case 93 + case 96: { + scorePresent_ = input.readBool(); + bitField0_ |= 0x00000800; + break; + } // case 96 + case 106: { + explainScore_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00001000; + break; + } // case 106 + case 112: { + explainScorePresent_ = input.readBool(); + bitField0_ |= 0x00002000; + break; + } // case 112 + case 120: { + isConsistent_ = input.readBool(); + bitField0_ |= 0x00004000; + break; + } // case 120 + case 130: { + generative_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00008000; + break; + } // case 130 + case 136: { + generativePresent_ = input.readBool(); + bitField0_ |= 0x00010000; + break; + } // case 136 + case 144: { + isConsistentPresent_ = input.readBool(); + bitField0_ |= 0x00020000; + break; + } // case 144 + case 154: { + vectorBytes_ = input.readBytes(); + bitField0_ |= 0x00040000; + break; + } // case 154 + case 162: { + idAsBytes_ = input.readBytes(); + bitField0_ |= 0x00080000; + break; + } // case 162 + case 169: { + rerankScore_ = input.readDouble(); + bitField0_ |= 0x00100000; + break; + } // case 169 + case 176: { + rerankScorePresent_ = input.readBool(); + bitField0_ |= 0x00200000; + break; + } // case 176 + case 186: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.parser(), + extensionRegistry); + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(m); + } else { + vectorsBuilder_.addMessage(m); + } + break; + } // case 186 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object id_ = ""; + /** + * string id = 1; + * @return The id. + */ + public java.lang.String getId() { + java.lang.Object ref = id_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + id_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string id = 1; + * @return The bytes for id. + */ + public com.google.protobuf.ByteString + getIdBytes() { + java.lang.Object ref = id_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + id_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string id = 1; + * @param value The id to set. + * @return This builder for chaining. + */ + public Builder setId( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + id_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * string id = 1; + * @return This builder for chaining. + */ + public Builder clearId() { + id_ = getDefaultInstance().getId(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * string id = 1; + * @param value The bytes for id to set. + * @return This builder for chaining. + */ + public Builder setIdBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + id_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + + private com.google.protobuf.Internal.FloatList vector_ = emptyFloatList(); + private void ensureVectorIsMutable() { + if (!vector_.isModifiable()) { + vector_ = makeMutableCopy(vector_); + } + bitField0_ |= 0x00000002; + } + private void ensureVectorIsMutable(int capacity) { + if (!vector_.isModifiable()) { + vector_ = makeMutableCopy(vector_, capacity); + } + bitField0_ |= 0x00000002; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return A list containing the vector. + */ + @java.lang.Deprecated public java.util.List + getVectorList() { + vector_.makeImmutable(); + return vector_; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return The count of vector. + */ + @java.lang.Deprecated public int getVectorCount() { + return vector_.size(); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param index The index of the element to return. + * @return The vector at the given index. + */ + @java.lang.Deprecated public float getVector(int index) { + return vector_.getFloat(index); + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param index The index to set the value at. + * @param value The vector to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setVector( + int index, float value) { + + ensureVectorIsMutable(); + vector_.setFloat(index, value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param value The vector to add. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder addVector(float value) { + + ensureVectorIsMutable(); + vector_.addFloat(value); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @param values The vector to add. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder addAllVector( + java.lang.Iterable values) { + ensureVectorIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, vector_); + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + *
+       * protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED
+       * 
+ * + * repeated float vector = 2 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.vector is deprecated. + * See v1/search_get.proto;l=144 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearVector() { + vector_ = emptyFloatList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + + private long creationTimeUnix_ ; + /** + * int64 creation_time_unix = 3; + * @return The creationTimeUnix. + */ + @java.lang.Override + public long getCreationTimeUnix() { + return creationTimeUnix_; + } + /** + * int64 creation_time_unix = 3; + * @param value The creationTimeUnix to set. + * @return This builder for chaining. + */ + public Builder setCreationTimeUnix(long value) { + + creationTimeUnix_ = value; + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * int64 creation_time_unix = 3; + * @return This builder for chaining. + */ + public Builder clearCreationTimeUnix() { + bitField0_ = (bitField0_ & ~0x00000004); + creationTimeUnix_ = 0L; + onChanged(); + return this; + } + + private boolean creationTimeUnixPresent_ ; + /** + * bool creation_time_unix_present = 4; + * @return The creationTimeUnixPresent. + */ + @java.lang.Override + public boolean getCreationTimeUnixPresent() { + return creationTimeUnixPresent_; + } + /** + * bool creation_time_unix_present = 4; + * @param value The creationTimeUnixPresent to set. + * @return This builder for chaining. + */ + public Builder setCreationTimeUnixPresent(boolean value) { + + creationTimeUnixPresent_ = value; + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * bool creation_time_unix_present = 4; + * @return This builder for chaining. + */ + public Builder clearCreationTimeUnixPresent() { + bitField0_ = (bitField0_ & ~0x00000008); + creationTimeUnixPresent_ = false; + onChanged(); + return this; + } + + private long lastUpdateTimeUnix_ ; + /** + * int64 last_update_time_unix = 5; + * @return The lastUpdateTimeUnix. + */ + @java.lang.Override + public long getLastUpdateTimeUnix() { + return lastUpdateTimeUnix_; + } + /** + * int64 last_update_time_unix = 5; + * @param value The lastUpdateTimeUnix to set. + * @return This builder for chaining. + */ + public Builder setLastUpdateTimeUnix(long value) { + + lastUpdateTimeUnix_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * int64 last_update_time_unix = 5; + * @return This builder for chaining. + */ + public Builder clearLastUpdateTimeUnix() { + bitField0_ = (bitField0_ & ~0x00000010); + lastUpdateTimeUnix_ = 0L; + onChanged(); + return this; + } + + private boolean lastUpdateTimeUnixPresent_ ; + /** + * bool last_update_time_unix_present = 6; + * @return The lastUpdateTimeUnixPresent. + */ + @java.lang.Override + public boolean getLastUpdateTimeUnixPresent() { + return lastUpdateTimeUnixPresent_; + } + /** + * bool last_update_time_unix_present = 6; + * @param value The lastUpdateTimeUnixPresent to set. + * @return This builder for chaining. + */ + public Builder setLastUpdateTimeUnixPresent(boolean value) { + + lastUpdateTimeUnixPresent_ = value; + bitField0_ |= 0x00000020; + onChanged(); + return this; + } + /** + * bool last_update_time_unix_present = 6; + * @return This builder for chaining. + */ + public Builder clearLastUpdateTimeUnixPresent() { + bitField0_ = (bitField0_ & ~0x00000020); + lastUpdateTimeUnixPresent_ = false; + onChanged(); + return this; + } + + private float distance_ ; + /** + * float distance = 7; + * @return The distance. + */ + @java.lang.Override + public float getDistance() { + return distance_; + } + /** + * float distance = 7; + * @param value The distance to set. + * @return This builder for chaining. + */ + public Builder setDistance(float value) { + + distance_ = value; + bitField0_ |= 0x00000040; + onChanged(); + return this; + } + /** + * float distance = 7; + * @return This builder for chaining. + */ + public Builder clearDistance() { + bitField0_ = (bitField0_ & ~0x00000040); + distance_ = 0F; + onChanged(); + return this; + } + + private boolean distancePresent_ ; + /** + * bool distance_present = 8; + * @return The distancePresent. + */ + @java.lang.Override + public boolean getDistancePresent() { + return distancePresent_; + } + /** + * bool distance_present = 8; + * @param value The distancePresent to set. + * @return This builder for chaining. + */ + public Builder setDistancePresent(boolean value) { + + distancePresent_ = value; + bitField0_ |= 0x00000080; + onChanged(); + return this; + } + /** + * bool distance_present = 8; + * @return This builder for chaining. + */ + public Builder clearDistancePresent() { + bitField0_ = (bitField0_ & ~0x00000080); + distancePresent_ = false; + onChanged(); + return this; + } + + private float certainty_ ; + /** + * float certainty = 9; + * @return The certainty. + */ + @java.lang.Override + public float getCertainty() { + return certainty_; + } + /** + * float certainty = 9; + * @param value The certainty to set. + * @return This builder for chaining. + */ + public Builder setCertainty(float value) { + + certainty_ = value; + bitField0_ |= 0x00000100; + onChanged(); + return this; + } + /** + * float certainty = 9; + * @return This builder for chaining. + */ + public Builder clearCertainty() { + bitField0_ = (bitField0_ & ~0x00000100); + certainty_ = 0F; + onChanged(); + return this; + } + + private boolean certaintyPresent_ ; + /** + * bool certainty_present = 10; + * @return The certaintyPresent. + */ + @java.lang.Override + public boolean getCertaintyPresent() { + return certaintyPresent_; + } + /** + * bool certainty_present = 10; + * @param value The certaintyPresent to set. + * @return This builder for chaining. + */ + public Builder setCertaintyPresent(boolean value) { + + certaintyPresent_ = value; + bitField0_ |= 0x00000200; + onChanged(); + return this; + } + /** + * bool certainty_present = 10; + * @return This builder for chaining. + */ + public Builder clearCertaintyPresent() { + bitField0_ = (bitField0_ & ~0x00000200); + certaintyPresent_ = false; + onChanged(); + return this; + } + + private float score_ ; + /** + * float score = 11; + * @return The score. + */ + @java.lang.Override + public float getScore() { + return score_; + } + /** + * float score = 11; + * @param value The score to set. + * @return This builder for chaining. + */ + public Builder setScore(float value) { + + score_ = value; + bitField0_ |= 0x00000400; + onChanged(); + return this; + } + /** + * float score = 11; + * @return This builder for chaining. + */ + public Builder clearScore() { + bitField0_ = (bitField0_ & ~0x00000400); + score_ = 0F; + onChanged(); + return this; + } + + private boolean scorePresent_ ; + /** + * bool score_present = 12; + * @return The scorePresent. + */ + @java.lang.Override + public boolean getScorePresent() { + return scorePresent_; + } + /** + * bool score_present = 12; + * @param value The scorePresent to set. + * @return This builder for chaining. + */ + public Builder setScorePresent(boolean value) { + + scorePresent_ = value; + bitField0_ |= 0x00000800; + onChanged(); + return this; + } + /** + * bool score_present = 12; + * @return This builder for chaining. + */ + public Builder clearScorePresent() { + bitField0_ = (bitField0_ & ~0x00000800); + scorePresent_ = false; + onChanged(); + return this; + } + + private java.lang.Object explainScore_ = ""; + /** + * string explain_score = 13; + * @return The explainScore. + */ + public java.lang.String getExplainScore() { + java.lang.Object ref = explainScore_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + explainScore_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string explain_score = 13; + * @return The bytes for explainScore. + */ + public com.google.protobuf.ByteString + getExplainScoreBytes() { + java.lang.Object ref = explainScore_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + explainScore_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string explain_score = 13; + * @param value The explainScore to set. + * @return This builder for chaining. + */ + public Builder setExplainScore( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + explainScore_ = value; + bitField0_ |= 0x00001000; + onChanged(); + return this; + } + /** + * string explain_score = 13; + * @return This builder for chaining. + */ + public Builder clearExplainScore() { + explainScore_ = getDefaultInstance().getExplainScore(); + bitField0_ = (bitField0_ & ~0x00001000); + onChanged(); + return this; + } + /** + * string explain_score = 13; + * @param value The bytes for explainScore to set. + * @return This builder for chaining. + */ + public Builder setExplainScoreBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + explainScore_ = value; + bitField0_ |= 0x00001000; + onChanged(); + return this; + } + + private boolean explainScorePresent_ ; + /** + * bool explain_score_present = 14; + * @return The explainScorePresent. + */ + @java.lang.Override + public boolean getExplainScorePresent() { + return explainScorePresent_; + } + /** + * bool explain_score_present = 14; + * @param value The explainScorePresent to set. + * @return This builder for chaining. + */ + public Builder setExplainScorePresent(boolean value) { + + explainScorePresent_ = value; + bitField0_ |= 0x00002000; + onChanged(); + return this; + } + /** + * bool explain_score_present = 14; + * @return This builder for chaining. + */ + public Builder clearExplainScorePresent() { + bitField0_ = (bitField0_ & ~0x00002000); + explainScorePresent_ = false; + onChanged(); + return this; + } + + private boolean isConsistent_ ; + /** + * optional bool is_consistent = 15; + * @return Whether the isConsistent field is set. + */ + @java.lang.Override + public boolean hasIsConsistent() { + return ((bitField0_ & 0x00004000) != 0); + } + /** + * optional bool is_consistent = 15; + * @return The isConsistent. + */ + @java.lang.Override + public boolean getIsConsistent() { + return isConsistent_; + } + /** + * optional bool is_consistent = 15; + * @param value The isConsistent to set. + * @return This builder for chaining. + */ + public Builder setIsConsistent(boolean value) { + + isConsistent_ = value; + bitField0_ |= 0x00004000; + onChanged(); + return this; + } + /** + * optional bool is_consistent = 15; + * @return This builder for chaining. + */ + public Builder clearIsConsistent() { + bitField0_ = (bitField0_ & ~0x00004000); + isConsistent_ = false; + onChanged(); + return this; + } + + private java.lang.Object generative_ = ""; + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The generative. + */ + @java.lang.Deprecated public java.lang.String getGenerative() { + java.lang.Object ref = generative_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + generative_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return The bytes for generative. + */ + @java.lang.Deprecated public com.google.protobuf.ByteString + getGenerativeBytes() { + java.lang.Object ref = generative_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + generative_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @param value The generative to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setGenerative( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + generative_ = value; + bitField0_ |= 0x00008000; + onChanged(); + return this; + } + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearGenerative() { + generative_ = getDefaultInstance().getGenerative(); + bitField0_ = (bitField0_ & ~0x00008000); + onChanged(); + return this; + } + /** + * string generative = 16 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative is deprecated. + * See v1/search_get.proto;l=158 + * @param value The bytes for generative to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setGenerativeBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + generative_ = value; + bitField0_ |= 0x00008000; + onChanged(); + return this; + } + + private boolean generativePresent_ ; + /** + * bool generative_present = 17 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. + * See v1/search_get.proto;l=159 + * @return The generativePresent. + */ + @java.lang.Override + @java.lang.Deprecated public boolean getGenerativePresent() { + return generativePresent_; + } + /** + * bool generative_present = 17 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. + * See v1/search_get.proto;l=159 + * @param value The generativePresent to set. + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder setGenerativePresent(boolean value) { + + generativePresent_ = value; + bitField0_ |= 0x00010000; + onChanged(); + return this; + } + /** + * bool generative_present = 17 [deprecated = true]; + * @deprecated weaviate.v1.MetadataResult.generative_present is deprecated. + * See v1/search_get.proto;l=159 + * @return This builder for chaining. + */ + @java.lang.Deprecated public Builder clearGenerativePresent() { + bitField0_ = (bitField0_ & ~0x00010000); + generativePresent_ = false; + onChanged(); + return this; + } + + private boolean isConsistentPresent_ ; + /** + * bool is_consistent_present = 18; + * @return The isConsistentPresent. + */ + @java.lang.Override + public boolean getIsConsistentPresent() { + return isConsistentPresent_; + } + /** + * bool is_consistent_present = 18; + * @param value The isConsistentPresent to set. + * @return This builder for chaining. + */ + public Builder setIsConsistentPresent(boolean value) { + + isConsistentPresent_ = value; + bitField0_ |= 0x00020000; + onChanged(); + return this; + } + /** + * bool is_consistent_present = 18; + * @return This builder for chaining. + */ + public Builder clearIsConsistentPresent() { + bitField0_ = (bitField0_ & ~0x00020000); + isConsistentPresent_ = false; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString vectorBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes vector_bytes = 19; + * @return The vectorBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getVectorBytes() { + return vectorBytes_; + } + /** + * bytes vector_bytes = 19; + * @param value The vectorBytes to set. + * @return This builder for chaining. + */ + public Builder setVectorBytes(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + vectorBytes_ = value; + bitField0_ |= 0x00040000; + onChanged(); + return this; + } + /** + * bytes vector_bytes = 19; + * @return This builder for chaining. + */ + public Builder clearVectorBytes() { + bitField0_ = (bitField0_ & ~0x00040000); + vectorBytes_ = getDefaultInstance().getVectorBytes(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString idAsBytes_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes id_as_bytes = 20; + * @return The idAsBytes. + */ + @java.lang.Override + public com.google.protobuf.ByteString getIdAsBytes() { + return idAsBytes_; + } + /** + * bytes id_as_bytes = 20; + * @param value The idAsBytes to set. + * @return This builder for chaining. + */ + public Builder setIdAsBytes(com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + idAsBytes_ = value; + bitField0_ |= 0x00080000; + onChanged(); + return this; + } + /** + * bytes id_as_bytes = 20; + * @return This builder for chaining. + */ + public Builder clearIdAsBytes() { + bitField0_ = (bitField0_ & ~0x00080000); + idAsBytes_ = getDefaultInstance().getIdAsBytes(); + onChanged(); + return this; + } + + private double rerankScore_ ; + /** + * double rerank_score = 21; + * @return The rerankScore. + */ + @java.lang.Override + public double getRerankScore() { + return rerankScore_; + } + /** + * double rerank_score = 21; + * @param value The rerankScore to set. + * @return This builder for chaining. + */ + public Builder setRerankScore(double value) { + + rerankScore_ = value; + bitField0_ |= 0x00100000; + onChanged(); + return this; + } + /** + * double rerank_score = 21; + * @return This builder for chaining. + */ + public Builder clearRerankScore() { + bitField0_ = (bitField0_ & ~0x00100000); + rerankScore_ = 0D; + onChanged(); + return this; + } + + private boolean rerankScorePresent_ ; + /** + * bool rerank_score_present = 22; + * @return The rerankScorePresent. + */ + @java.lang.Override + public boolean getRerankScorePresent() { + return rerankScorePresent_; + } + /** + * bool rerank_score_present = 22; + * @param value The rerankScorePresent to set. + * @return This builder for chaining. + */ + public Builder setRerankScorePresent(boolean value) { + + rerankScorePresent_ = value; + bitField0_ |= 0x00200000; + onChanged(); + return this; + } + /** + * bool rerank_score_present = 22; + * @return This builder for chaining. + */ + public Builder clearRerankScorePresent() { + bitField0_ = (bitField0_ & ~0x00200000); + rerankScorePresent_ = false; + onChanged(); + return this; + } + + private java.util.List vectors_ = + java.util.Collections.emptyList(); + private void ensureVectorsIsMutable() { + if (!((bitField0_ & 0x00400000) != 0)) { + vectors_ = new java.util.ArrayList(vectors_); + bitField0_ |= 0x00400000; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> vectorsBuilder_; + + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List getVectorsList() { + if (vectorsBuilder_ == null) { + return java.util.Collections.unmodifiableList(vectors_); + } else { + return vectorsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public int getVectorsCount() { + if (vectorsBuilder_ == null) { + return vectors_.size(); + } else { + return vectorsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors getVectors(int index) { + if (vectorsBuilder_ == null) { + return vectors_.get(index); + } else { + return vectorsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder setVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.set(index, value); + onChanged(); + } else { + vectorsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder setVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.set(index, builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.add(value); + onChanged(); + } else { + vectorsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors value) { + if (vectorsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureVectorsIsMutable(); + vectors_.add(index, value); + onChanged(); + } else { + vectorsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addVectors( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder builderForValue) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.add(index, builderForValue.build()); + onChanged(); + } else { + vectorsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder addAllVectors( + java.lang.Iterable values) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, vectors_); + onChanged(); + } else { + vectorsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder clearVectors() { + if (vectorsBuilder_ == null) { + vectors_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00400000); + onChanged(); + } else { + vectorsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public Builder removeVectors(int index) { + if (vectorsBuilder_ == null) { + ensureVectorsIsMutable(); + vectors_.remove(index); + onChanged(); + } else { + vectorsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder getVectorsBuilder( + int index) { + return getVectorsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder getVectorsOrBuilder( + int index) { + if (vectorsBuilder_ == null) { + return vectors_.get(index); } else { + return vectorsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List + getVectorsOrBuilderList() { + if (vectorsBuilder_ != null) { + return vectorsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(vectors_); + } + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder() { + return getVectorsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder addVectorsBuilder( + int index) { + return getVectorsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.Vectors vectors = 23; + */ + public java.util.List + getVectorsBuilderList() { + return getVectorsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder> + getVectorsFieldBuilder() { + if (vectorsBuilder_ == null) { + vectorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.Vectors.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.VectorsOrBuilder>( + vectors_, + ((bitField0_ & 0x00400000) != 0), + getParentForChildren(), + isClean()); + vectors_ = null; + } + return vectorsBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.MetadataResult) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.MetadataResult) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public MetadataResult parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface PropertiesResultOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.PropertiesResult) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + java.util.List + getRefPropsList(); + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index); + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + int getRefPropsCount(); + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + java.util.List + getRefPropsOrBuilderList(); + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( + int index); + + /** + * string target_collection = 3; + * @return The targetCollection. + */ + java.lang.String getTargetCollection(); + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + com.google.protobuf.ByteString + getTargetCollectionBytes(); + + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return Whether the metadata field is set. + */ + boolean hasMetadata(); + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return The metadata. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata(); + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder(); + + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return Whether the nonRefProps field is set. + */ + boolean hasNonRefProps(); + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return The nonRefProps. + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getNonRefProps(); + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder(); + + /** + * bool ref_props_requested = 12; + * @return The refPropsRequested. + */ + boolean getRefPropsRequested(); + } + /** + * Protobuf type {@code weaviate.v1.PropertiesResult} + */ + public static final class PropertiesResult extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.PropertiesResult) + PropertiesResultOrBuilder { + private static final long serialVersionUID = 0L; + // Use PropertiesResult.newBuilder() to construct. + private PropertiesResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private PropertiesResult() { + refProps_ = java.util.Collections.emptyList(); + targetCollection_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new PropertiesResult(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder.class); + } + + private int bitField0_; + public static final int REF_PROPS_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private java.util.List refProps_; + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + @java.lang.Override + public java.util.List getRefPropsList() { + return refProps_; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + @java.lang.Override + public java.util.List + getRefPropsOrBuilderList() { + return refProps_; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + @java.lang.Override + public int getRefPropsCount() { + return refProps_.size(); + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index) { + return refProps_.get(index); + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( + int index) { + return refProps_.get(index); + } + + public static final int TARGET_COLLECTION_FIELD_NUMBER = 3; + @SuppressWarnings("serial") + private volatile java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 3; + * @return The targetCollection. + */ + @java.lang.Override + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } + } + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int METADATA_FIELD_NUMBER = 4; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult metadata_; + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return Whether the metadata field is set. + */ + @java.lang.Override + public boolean hasMetadata() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return The metadata. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + + public static final int NON_REF_PROPS_FIELD_NUMBER = 11; + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties nonRefProps_; + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return Whether the nonRefProps field is set. + */ + @java.lang.Override + public boolean hasNonRefProps() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return The nonRefProps. + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getNonRefProps() { + return nonRefProps_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder() { + return nonRefProps_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; + } + + public static final int REF_PROPS_REQUESTED_FIELD_NUMBER = 12; + private boolean refPropsRequested_ = false; + /** + * bool ref_props_requested = 12; + * @return The refPropsRequested. + */ + @java.lang.Override + public boolean getRefPropsRequested() { + return refPropsRequested_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < refProps_.size(); i++) { + output.writeMessage(2, refProps_.get(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, targetCollection_); + } + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(4, getMetadata()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(11, getNonRefProps()); + } + if (refPropsRequested_ != false) { + output.writeBool(12, refPropsRequested_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < refProps_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, refProps_.get(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(targetCollection_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, targetCollection_); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getMetadata()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(11, getNonRefProps()); + } + if (refPropsRequested_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(12, refPropsRequested_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult) obj; + + if (!getRefPropsList() + .equals(other.getRefPropsList())) return false; + if (!getTargetCollection() + .equals(other.getTargetCollection())) return false; + if (hasMetadata() != other.hasMetadata()) return false; + if (hasMetadata()) { + if (!getMetadata() + .equals(other.getMetadata())) return false; + } + if (hasNonRefProps() != other.hasNonRefProps()) return false; + if (hasNonRefProps()) { + if (!getNonRefProps() + .equals(other.getNonRefProps())) return false; + } + if (getRefPropsRequested() + != other.getRefPropsRequested()) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getRefPropsCount() > 0) { + hash = (37 * hash) + REF_PROPS_FIELD_NUMBER; + hash = (53 * hash) + getRefPropsList().hashCode(); + } + hash = (37 * hash) + TARGET_COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getTargetCollection().hashCode(); + if (hasMetadata()) { + hash = (37 * hash) + METADATA_FIELD_NUMBER; + hash = (53 * hash) + getMetadata().hashCode(); + } + if (hasNonRefProps()) { + hash = (37 * hash) + NON_REF_PROPS_FIELD_NUMBER; + hash = (53 * hash) + getNonRefProps().hashCode(); + } + hash = (37 * hash) + REF_PROPS_REQUESTED_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getRefPropsRequested()); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.PropertiesResult} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.PropertiesResult) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getRefPropsFieldBuilder(); + getMetadataFieldBuilder(); + getNonRefPropsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + if (refPropsBuilder_ == null) { + refProps_ = java.util.Collections.emptyList(); + } else { + refProps_ = null; + refPropsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + targetCollection_ = ""; + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + nonRefProps_ = null; + if (nonRefPropsBuilder_ != null) { + nonRefPropsBuilder_.dispose(); + nonRefPropsBuilder_ = null; + } + refPropsRequested_ = false; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_PropertiesResult_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult result) { + if (refPropsBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + refProps_ = java.util.Collections.unmodifiableList(refProps_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.refProps_ = refProps_; + } else { + result.refProps_ = refPropsBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.targetCollection_ = targetCollection_; + } + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000004) != 0)) { + result.metadata_ = metadataBuilder_ == null + ? metadata_ + : metadataBuilder_.build(); + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.nonRefProps_ = nonRefPropsBuilder_ == null + ? nonRefProps_ + : nonRefPropsBuilder_.build(); + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.refPropsRequested_ = refPropsRequested_; + } + result.bitField0_ |= to_bitField0_; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()) return this; + if (refPropsBuilder_ == null) { + if (!other.refProps_.isEmpty()) { + if (refProps_.isEmpty()) { + refProps_ = other.refProps_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureRefPropsIsMutable(); + refProps_.addAll(other.refProps_); + } + onChanged(); + } + } else { + if (!other.refProps_.isEmpty()) { + if (refPropsBuilder_.isEmpty()) { + refPropsBuilder_.dispose(); + refPropsBuilder_ = null; + refProps_ = other.refProps_; + bitField0_ = (bitField0_ & ~0x00000001); + refPropsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getRefPropsFieldBuilder() : null; + } else { + refPropsBuilder_.addAllMessages(other.refProps_); + } + } + } + if (!other.getTargetCollection().isEmpty()) { + targetCollection_ = other.targetCollection_; + bitField0_ |= 0x00000002; + onChanged(); + } + if (other.hasMetadata()) { + mergeMetadata(other.getMetadata()); + } + if (other.hasNonRefProps()) { + mergeNonRefProps(other.getNonRefProps()); + } + if (other.getRefPropsRequested() != false) { + setRefPropsRequested(other.getRefPropsRequested()); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 18: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.parser(), + extensionRegistry); + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + refProps_.add(m); + } else { + refPropsBuilder_.addMessage(m); + } + break; + } // case 18 + case 26: { + targetCollection_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 26 + case 34: { + input.readMessage( + getMetadataFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000004; + break; + } // case 34 + case 90: { + input.readMessage( + getNonRefPropsFieldBuilder().getBuilder(), + extensionRegistry); + bitField0_ |= 0x00000008; + break; + } // case 90 + case 96: { + refPropsRequested_ = input.readBool(); + bitField0_ |= 0x00000010; + break; + } // case 96 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.util.List refProps_ = + java.util.Collections.emptyList(); + private void ensureRefPropsIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + refProps_ = new java.util.ArrayList(refProps_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder> refPropsBuilder_; + + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public java.util.List getRefPropsList() { + if (refPropsBuilder_ == null) { + return java.util.Collections.unmodifiableList(refProps_); + } else { + return refPropsBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public int getRefPropsCount() { + if (refPropsBuilder_ == null) { + return refProps_.size(); + } else { + return refPropsBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getRefProps(int index) { + if (refPropsBuilder_ == null) { + return refProps_.get(index); + } else { + return refPropsBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder setRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult value) { + if (refPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropsIsMutable(); + refProps_.set(index, value); + onChanged(); + } else { + refPropsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder setRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + refProps_.set(index, builderForValue.build()); + onChanged(); + } else { + refPropsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder addRefProps(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult value) { + if (refPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropsIsMutable(); + refProps_.add(value); + onChanged(); + } else { + refPropsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder addRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult value) { + if (refPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRefPropsIsMutable(); + refProps_.add(index, value); + onChanged(); + } else { + refPropsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder addRefProps( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + refProps_.add(builderForValue.build()); + onChanged(); + } else { + refPropsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder addRefProps( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder builderForValue) { + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + refProps_.add(index, builderForValue.build()); + onChanged(); + } else { + refPropsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder addAllRefProps( + java.lang.Iterable values) { + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, refProps_); + onChanged(); + } else { + refPropsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder clearRefProps() { + if (refPropsBuilder_ == null) { + refProps_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + refPropsBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public Builder removeRefProps(int index) { + if (refPropsBuilder_ == null) { + ensureRefPropsIsMutable(); + refProps_.remove(index); + onChanged(); + } else { + refPropsBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder getRefPropsBuilder( + int index) { + return getRefPropsFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder getRefPropsOrBuilder( + int index) { + if (refPropsBuilder_ == null) { + return refProps_.get(index); } else { + return refPropsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public java.util.List + getRefPropsOrBuilderList() { + if (refPropsBuilder_ != null) { + return refPropsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(refProps_); + } + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder addRefPropsBuilder() { + return getRefPropsFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder addRefPropsBuilder( + int index) { + return getRefPropsFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.RefPropertiesResult ref_props = 2; + */ + public java.util.List + getRefPropsBuilderList() { + return getRefPropsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder> + getRefPropsFieldBuilder() { + if (refPropsBuilder_ == null) { + refPropsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder>( + refProps_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + refProps_ = null; + } + return refPropsBuilder_; + } + + private java.lang.Object targetCollection_ = ""; + /** + * string target_collection = 3; + * @return The targetCollection. + */ + public java.lang.String getTargetCollection() { + java.lang.Object ref = targetCollection_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + targetCollection_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string target_collection = 3; + * @return The bytes for targetCollection. + */ + public com.google.protobuf.ByteString + getTargetCollectionBytes() { + java.lang.Object ref = targetCollection_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + targetCollection_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string target_collection = 3; + * @param value The targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollection( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + targetCollection_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string target_collection = 3; + * @return This builder for chaining. + */ + public Builder clearTargetCollection() { + targetCollection_ = getDefaultInstance().getTargetCollection(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string target_collection = 3; + * @param value The bytes for targetCollection to set. + * @return This builder for chaining. + */ + public Builder setTargetCollectionBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + targetCollection_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult metadata_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder> metadataBuilder_; + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return Whether the metadata field is set. + */ + public boolean hasMetadata() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + * @return The metadata. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult getMetadata() { + if (metadataBuilder_ == null) { + return metadata_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } else { + return metadataBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public Builder setMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult value) { + if (metadataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + metadata_ = value; + } else { + metadataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public Builder setMetadata( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder builderForValue) { + if (metadataBuilder_ == null) { + metadata_ = builderForValue.build(); + } else { + metadataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public Builder mergeMetadata(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult value) { + if (metadataBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + metadata_ != null && + metadata_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance()) { + getMetadataBuilder().mergeFrom(value); + } else { + metadata_ = value; + } + } else { + metadataBuilder_.mergeFrom(value); + } + if (metadata_ != null) { + bitField0_ |= 0x00000004; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public Builder clearMetadata() { + bitField0_ = (bitField0_ & ~0x00000004); + metadata_ = null; + if (metadataBuilder_ != null) { + metadataBuilder_.dispose(); + metadataBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder getMetadataBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getMetadataFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder getMetadataOrBuilder() { + if (metadataBuilder_ != null) { + return metadataBuilder_.getMessageOrBuilder(); + } else { + return metadata_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.getDefaultInstance() : metadata_; + } + } + /** + * .weaviate.v1.MetadataResult metadata = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder> + getMetadataFieldBuilder() { + if (metadataBuilder_ == null) { + metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.MetadataResultOrBuilder>( + getMetadata(), + getParentForChildren(), + isClean()); + metadata_ = null; + } + return metadataBuilder_; + } + + private io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties nonRefProps_; + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> nonRefPropsBuilder_; + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return Whether the nonRefProps field is set. + */ + public boolean hasNonRefProps() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + * @return The nonRefProps. + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties getNonRefProps() { + if (nonRefPropsBuilder_ == null) { + return nonRefProps_ == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; + } else { + return nonRefPropsBuilder_.getMessage(); + } + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public Builder setNonRefProps(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (nonRefPropsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nonRefProps_ = value; + } else { + nonRefPropsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public Builder setNonRefProps( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder builderForValue) { + if (nonRefPropsBuilder_ == null) { + nonRefProps_ = builderForValue.build(); + } else { + nonRefPropsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + onChanged(); + return this; + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public Builder mergeNonRefProps(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties value) { + if (nonRefPropsBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + nonRefProps_ != null && + nonRefProps_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance()) { + getNonRefPropsBuilder().mergeFrom(value); + } else { + nonRefProps_ = value; + } + } else { + nonRefPropsBuilder_.mergeFrom(value); + } + if (nonRefProps_ != null) { + bitField0_ |= 0x00000008; + onChanged(); + } + return this; + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public Builder clearNonRefProps() { + bitField0_ = (bitField0_ & ~0x00000008); + nonRefProps_ = null; + if (nonRefPropsBuilder_ != null) { + nonRefPropsBuilder_.dispose(); + nonRefPropsBuilder_ = null; + } + onChanged(); + return this; + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder getNonRefPropsBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getNonRefPropsFieldBuilder().getBuilder(); + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder getNonRefPropsOrBuilder() { + if (nonRefPropsBuilder_ != null) { + return nonRefPropsBuilder_.getMessageOrBuilder(); + } else { + return nonRefProps_ == null ? + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.getDefaultInstance() : nonRefProps_; + } + } + /** + * .weaviate.v1.Properties non_ref_props = 11; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder> + getNonRefPropsFieldBuilder() { + if (nonRefPropsBuilder_ == null) { + nonRefPropsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.Properties.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.PropertiesOrBuilder>( + getNonRefProps(), + getParentForChildren(), + isClean()); + nonRefProps_ = null; + } + return nonRefPropsBuilder_; + } + + private boolean refPropsRequested_ ; + /** + * bool ref_props_requested = 12; + * @return The refPropsRequested. + */ + @java.lang.Override + public boolean getRefPropsRequested() { + return refPropsRequested_; + } + /** + * bool ref_props_requested = 12; + * @param value The refPropsRequested to set. + * @return This builder for chaining. + */ + public Builder setRefPropsRequested(boolean value) { + + refPropsRequested_ = value; + bitField0_ |= 0x00000010; + onChanged(); + return this; + } + /** + * bool ref_props_requested = 12; + * @return This builder for chaining. + */ + public Builder clearRefPropsRequested() { + bitField0_ = (bitField0_ & ~0x00000010); + refPropsRequested_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.PropertiesResult) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.PropertiesResult) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public PropertiesResult parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface RefPropertiesResultOrBuilder extends + // @@protoc_insertion_point(interface_extends:weaviate.v1.RefPropertiesResult) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + java.util.List + getPropertiesList(); + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties(int index); + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + int getPropertiesCount(); + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + java.util.List + getPropertiesOrBuilderList(); + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( + int index); + + /** + * string prop_name = 2; + * @return The propName. + */ + java.lang.String getPropName(); + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + com.google.protobuf.ByteString + getPropNameBytes(); + } + /** + * Protobuf type {@code weaviate.v1.RefPropertiesResult} + */ + public static final class RefPropertiesResult extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:weaviate.v1.RefPropertiesResult) + RefPropertiesResultOrBuilder { + private static final long serialVersionUID = 0L; + // Use RefPropertiesResult.newBuilder() to construct. + private RefPropertiesResult(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private RefPropertiesResult() { + properties_ = java.util.Collections.emptyList(); + propName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new RefPropertiesResult(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder.class); + } + + public static final int PROPERTIES_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private java.util.List properties_; + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public java.util.List getPropertiesList() { + return properties_; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public java.util.List + getPropertiesOrBuilderList() { + return properties_; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public int getPropertiesCount() { + return properties_.size(); + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties(int index) { + return properties_.get(index); + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( + int index) { + return properties_.get(index); + } + + public static final int PROP_NAME_FIELD_NUMBER = 2; + @SuppressWarnings("serial") + private volatile java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + @java.lang.Override + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < properties_.size(); i++) { + output.writeMessage(1, properties_.get(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, propName_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < properties_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, properties_.get(i)); + } + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(propName_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, propName_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult)) { + return super.equals(obj); + } + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult) obj; + + if (!getPropertiesList() + .equals(other.getPropertiesList())) return false; + if (!getPropName() + .equals(other.getPropName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getPropertiesCount() > 0) { + hash = (37 * hash) + PROPERTIES_FIELD_NUMBER; + hash = (53 * hash) + getPropertiesList().hashCode(); + } + hash = (37 * hash) + PROP_NAME_FIELD_NUMBER; + hash = (53 * hash) + getPropName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code weaviate.v1.RefPropertiesResult} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:weaviate.v1.RefPropertiesResult) + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResultOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.Builder.class); + } + + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + if (propertiesBuilder_ == null) { + properties_ = java.util.Collections.emptyList(); + } else { + properties_ = null; + propertiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + propName_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.internal_static_weaviate_v1_RefPropertiesResult_descriptor; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance(); + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult(this); + buildPartialRepeatedFields(result); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult result) { + if (propertiesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + properties_ = java.util.Collections.unmodifiableList(properties_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.properties_ = properties_; + } else { + result.properties_ = propertiesBuilder_.build(); + } + } + + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.propName_ = propName_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult.getDefaultInstance()) return this; + if (propertiesBuilder_ == null) { + if (!other.properties_.isEmpty()) { + if (properties_.isEmpty()) { + properties_ = other.properties_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensurePropertiesIsMutable(); + properties_.addAll(other.properties_); + } + onChanged(); + } + } else { + if (!other.properties_.isEmpty()) { + if (propertiesBuilder_.isEmpty()) { + propertiesBuilder_.dispose(); + propertiesBuilder_ = null; + properties_ = other.properties_; + bitField0_ = (bitField0_ & ~0x00000001); + propertiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getPropertiesFieldBuilder() : null; + } else { + propertiesBuilder_.addAllMessages(other.properties_); + } + } + } + if (!other.getPropName().isEmpty()) { + propName_ = other.propName_; + bitField0_ |= 0x00000002; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult m = + input.readMessage( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.parser(), + extensionRegistry); + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + properties_.add(m); + } else { + propertiesBuilder_.addMessage(m); + } + break; + } // case 10 + case 18: { + propName_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000002; + break; + } // case 18 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.util.List properties_ = + java.util.Collections.emptyList(); + private void ensurePropertiesIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + properties_ = new java.util.ArrayList(properties_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder> propertiesBuilder_; + + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public java.util.List getPropertiesList() { + if (propertiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(properties_); + } else { + return propertiesBuilder_.getMessageList(); + } + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public int getPropertiesCount() { + if (propertiesBuilder_ == null) { + return properties_.size(); + } else { + return propertiesBuilder_.getCount(); + } + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult getProperties(int index) { + if (propertiesBuilder_ == null) { + return properties_.get(index); + } else { + return propertiesBuilder_.getMessage(index); + } + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder setProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePropertiesIsMutable(); + properties_.set(index, value); + onChanged(); + } else { + propertiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder setProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + properties_.set(index, builderForValue.build()); + onChanged(); + } else { + propertiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder addProperties(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePropertiesIsMutable(); + properties_.add(value); + onChanged(); + } else { + propertiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder addProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult value) { + if (propertiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensurePropertiesIsMutable(); + properties_.add(index, value); + onChanged(); + } else { + propertiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder addProperties( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + properties_.add(builderForValue.build()); + onChanged(); + } else { + propertiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder addProperties( + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder builderForValue) { + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + properties_.add(index, builderForValue.build()); + onChanged(); + } else { + propertiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder addAllProperties( + java.lang.Iterable values) { + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, properties_); + onChanged(); + } else { + propertiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder clearProperties() { + if (propertiesBuilder_ == null) { + properties_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + propertiesBuilder_.clear(); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public Builder removeProperties(int index) { + if (propertiesBuilder_ == null) { + ensurePropertiesIsMutable(); + properties_.remove(index); + onChanged(); + } else { + propertiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder getPropertiesBuilder( + int index) { + return getPropertiesFieldBuilder().getBuilder(index); + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder getPropertiesOrBuilder( + int index) { + if (propertiesBuilder_ == null) { + return properties_.get(index); } else { + return propertiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public java.util.List + getPropertiesOrBuilderList() { + if (propertiesBuilder_ != null) { + return propertiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(properties_); + } + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder addPropertiesBuilder() { + return getPropertiesFieldBuilder().addBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder addPropertiesBuilder( + int index) { + return getPropertiesFieldBuilder().addBuilder( + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.getDefaultInstance()); + } + /** + * repeated .weaviate.v1.PropertiesResult properties = 1; + */ + public java.util.List + getPropertiesBuilderList() { + return getPropertiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder> + getPropertiesFieldBuilder() { + if (propertiesBuilder_ == null) { + propertiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResult.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.PropertiesResultOrBuilder>( + properties_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + properties_ = null; + } + return propertiesBuilder_; + } + + private java.lang.Object propName_ = ""; + /** + * string prop_name = 2; + * @return The propName. + */ + public java.lang.String getPropName() { + java.lang.Object ref = propName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + propName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string prop_name = 2; + * @return The bytes for propName. + */ + public com.google.protobuf.ByteString + getPropNameBytes() { + java.lang.Object ref = propName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + propName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string prop_name = 2; + * @param value The propName to set. + * @return This builder for chaining. + */ + public Builder setPropName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @return This builder for chaining. + */ + public Builder clearPropName() { + propName_ = getDefaultInstance().getPropName(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + /** + * string prop_name = 2; + * @param value The bytes for propName to set. + * @return This builder for chaining. + */ + public Builder setPropNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + propName_ = value; + bitField0_ |= 0x00000002; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:weaviate.v1.RefPropertiesResult) + } + + // @@protoc_insertion_point(class_scope:weaviate.v1.RefPropertiesResult) + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult(); + } + + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public RefPropertiesResult parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet.RefPropertiesResult getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_SearchRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_SearchRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_GroupBy_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_GroupBy_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_SortBy_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_SortBy_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_MetadataRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_PropertiesRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_RefPropertiesRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_Rerank_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_Rerank_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_SearchReply_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_SearchReply_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_RerankReply_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_RerankReply_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_GroupByResult_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_GroupByResult_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_SearchResult_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_SearchResult_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_MetadataResult_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_MetadataResult_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_PropertiesResult_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_weaviate_v1_RefPropertiesResult_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\023v1/search_get.proto\022\013weaviate.v1\032\rv1/b" + + "ase.proto\032\024v1/base_search.proto\032\023v1/gene" + + "rative.proto\032\023v1/properties.proto\"\234\013\n\rSe" + + "archRequest\022\022\n\ncollection\030\001 \001(\t\022\016\n\006tenan" + + "t\030\n \001(\t\022=\n\021consistency_level\030\013 \001(\0162\035.wea" + + "viate.v1.ConsistencyLevelH\000\210\001\001\0227\n\nproper" + + "ties\030\024 \001(\0132\036.weaviate.v1.PropertiesReque" + + "stH\001\210\001\001\0223\n\010metadata\030\025 \001(\0132\034.weaviate.v1." + + "MetadataRequestH\002\210\001\001\022+\n\010group_by\030\026 \001(\0132\024" + + ".weaviate.v1.GroupByH\003\210\001\001\022\r\n\005limit\030\036 \001(\r" + + "\022\016\n\006offset\030\037 \001(\r\022\017\n\007autocut\030 \001(\r\022\r\n\005aft" + + "er\030! \001(\t\022$\n\007sort_by\030\" \003(\0132\023.weaviate.v1." + + "SortBy\022*\n\007filters\030( \001(\0132\024.weaviate.v1.Fi" + + "ltersH\004\210\001\001\022/\n\rhybrid_search\030) \001(\0132\023.weav" + + "iate.v1.HybridH\005\210\001\001\022+\n\013bm25_search\030* \001(\013" + + "2\021.weaviate.v1.BM25H\006\210\001\001\0221\n\013near_vector\030" + + "+ \001(\0132\027.weaviate.v1.NearVectorH\007\210\001\001\0221\n\013n" + + "ear_object\030, \001(\0132\027.weaviate.v1.NearObjec" + + "tH\010\210\001\001\0223\n\tnear_text\030- \001(\0132\033.weaviate.v1." + + "NearTextSearchH\t\210\001\001\0225\n\nnear_image\030. \001(\0132" + + "\034.weaviate.v1.NearImageSearchH\n\210\001\001\0225\n\nne" + + "ar_audio\030/ \001(\0132\034.weaviate.v1.NearAudioSe" + + "archH\013\210\001\001\0225\n\nnear_video\0300 \001(\0132\034.weaviate" + + ".v1.NearVideoSearchH\014\210\001\001\0225\n\nnear_depth\0301" + + " \001(\0132\034.weaviate.v1.NearDepthSearchH\r\210\001\001\022" + + "9\n\014near_thermal\0302 \001(\0132\036.weaviate.v1.Near" + + "ThermalSearchH\016\210\001\001\0221\n\010near_imu\0303 \001(\0132\032.w" + + "eaviate.v1.NearIMUSearchH\017\210\001\001\0226\n\ngenerat" + + "ive\030< \001(\0132\035.weaviate.v1.GenerativeSearch" + + "H\020\210\001\001\022(\n\006rerank\030= \001(\0132\023.weaviate.v1.Rera" + + "nkH\021\210\001\001\022\030\n\014uses_123_api\030d \001(\010B\002\030\001\022\030\n\014use" + + "s_125_api\030e \001(\010B\002\030\001\022\024\n\014uses_127_api\030f \001(" + + "\010B\024\n\022_consistency_levelB\r\n\013_propertiesB\013" + + "\n\t_metadataB\013\n\t_group_byB\n\n\010_filtersB\020\n\016" + + "_hybrid_searchB\016\n\014_bm25_searchB\016\n\014_near_" + + "vectorB\016\n\014_near_objectB\014\n\n_near_textB\r\n\013" + + "_near_imageB\r\n\013_near_audioB\r\n\013_near_vide" + + "oB\r\n\013_near_depthB\017\n\r_near_thermalB\013\n\t_ne" + + "ar_imuB\r\n\013_generativeB\t\n\007_rerank\"L\n\007Grou" + + "pBy\022\014\n\004path\030\001 \003(\t\022\030\n\020number_of_groups\030\002 " + + "\001(\005\022\031\n\021objects_per_group\030\003 \001(\005\")\n\006SortBy" + + "\022\021\n\tascending\030\001 \001(\010\022\014\n\004path\030\002 \003(\t\"\335\001\n\017Me" + + "tadataRequest\022\014\n\004uuid\030\001 \001(\010\022\016\n\006vector\030\002 " + + "\001(\010\022\032\n\022creation_time_unix\030\003 \001(\010\022\035\n\025last_" + + "update_time_unix\030\004 \001(\010\022\020\n\010distance\030\005 \001(\010" + + "\022\021\n\tcertainty\030\006 \001(\010\022\r\n\005score\030\007 \001(\010\022\025\n\rex" + + "plain_score\030\010 \001(\010\022\025\n\ris_consistent\030\t \001(\010" + + "\022\017\n\007vectors\030\n \003(\t\"\321\001\n\021PropertiesRequest\022" + + "\032\n\022non_ref_properties\030\001 \003(\t\0229\n\016ref_prope" + + "rties\030\002 \003(\0132!.weaviate.v1.RefPropertiesR" + + "equest\022?\n\021object_properties\030\003 \003(\0132$.weav" + + "iate.v1.ObjectPropertiesRequest\022$\n\034retur" + + "n_all_nonref_properties\030\013 \001(\010\"\213\001\n\027Object" + + "PropertiesRequest\022\021\n\tprop_name\030\001 \001(\t\022\034\n\024" + + "primitive_properties\030\002 \003(\t\022?\n\021object_pro" + + "perties\030\003 \003(\0132$.weaviate.v1.ObjectProper" + + "tiesRequest\"\261\001\n\024RefPropertiesRequest\022\032\n\022" + + "reference_property\030\001 \001(\t\0222\n\nproperties\030\002" + + " \001(\0132\036.weaviate.v1.PropertiesRequest\022.\n\010" + + "metadata\030\003 \001(\0132\034.weaviate.v1.MetadataReq" + + "uest\022\031\n\021target_collection\030\004 \001(\t\"8\n\006Reran" + + "k\022\020\n\010property\030\001 \001(\t\022\022\n\005query\030\002 \001(\tH\000\210\001\001B" + + "\010\n\006_query\"\256\002\n\013SearchReply\022\014\n\004took\030\001 \001(\002\022" + + "*\n\007results\030\002 \003(\0132\031.weaviate.v1.SearchRes" + + "ult\022*\n\031generative_grouped_result\030\003 \001(\tB\002" + + "\030\001H\000\210\001\001\0224\n\020group_by_results\030\004 \003(\0132\032.weav" + + "iate.v1.GroupByResult\022F\n\032generative_grou" + + "ped_results\030\005 \001(\0132\035.weaviate.v1.Generati" + + "veResultH\001\210\001\001B\034\n\032_generative_grouped_res" + + "ultB\035\n\033_generative_grouped_results\"\034\n\013Re" + + "rankReply\022\r\n\005score\030\001 \001(\001\"\351\002\n\rGroupByResu" + + "lt\022\014\n\004name\030\001 \001(\t\022\024\n\014min_distance\030\002 \001(\002\022\024" + + "\n\014max_distance\030\003 \001(\002\022\031\n\021number_of_object" + + "s\030\004 \001(\003\022*\n\007objects\030\005 \003(\0132\031.weaviate.v1.S" + + "earchResult\022-\n\006rerank\030\006 \001(\0132\030.weaviate.v" + + "1.RerankReplyH\000\210\001\001\0229\n\ngenerative\030\007 \001(\0132\034" + + ".weaviate.v1.GenerativeReplyB\002\030\001H\001\210\001\001\022=\n" + + "\021generative_result\030\010 \001(\0132\035.weaviate.v1.G" + + "enerativeResultH\002\210\001\001B\t\n\007_rerankB\r\n\013_gene" + + "rativeB\024\n\022_generative_result\"\267\001\n\014SearchR" + + "esult\0221\n\nproperties\030\001 \001(\0132\035.weaviate.v1." + + "PropertiesResult\022-\n\010metadata\030\002 \001(\0132\033.wea" + + "viate.v1.MetadataResult\0226\n\ngenerative\030\003 " + + "\001(\0132\035.weaviate.v1.GenerativeResultH\000\210\001\001B" + + "\r\n\013_generative\"\367\004\n\016MetadataResult\022\n\n\002id\030" + + "\001 \001(\t\022\022\n\006vector\030\002 \003(\002B\002\030\001\022\032\n\022creation_ti" + + "me_unix\030\003 \001(\003\022\"\n\032creation_time_unix_pres" + + "ent\030\004 \001(\010\022\035\n\025last_update_time_unix\030\005 \001(\003" + + "\022%\n\035last_update_time_unix_present\030\006 \001(\010\022" + + "\020\n\010distance\030\007 \001(\002\022\030\n\020distance_present\030\010 " + + "\001(\010\022\021\n\tcertainty\030\t \001(\002\022\031\n\021certainty_pres" + + "ent\030\n \001(\010\022\r\n\005score\030\013 \001(\002\022\025\n\rscore_presen" + + "t\030\014 \001(\010\022\025\n\rexplain_score\030\r \001(\t\022\035\n\025explai" + + "n_score_present\030\016 \001(\010\022\032\n\ris_consistent\030\017" + + " \001(\010H\000\210\001\001\022\026\n\ngenerative\030\020 \001(\tB\002\030\001\022\036\n\022gen" + + "erative_present\030\021 \001(\010B\002\030\001\022\035\n\025is_consiste" + + "nt_present\030\022 \001(\010\022\024\n\014vector_bytes\030\023 \001(\014\022\023" + + "\n\013id_as_bytes\030\024 \001(\014\022\024\n\014rerank_score\030\025 \001(" + + "\001\022\034\n\024rerank_score_present\030\026 \001(\010\022%\n\007vecto" + + "rs\030\027 \003(\0132\024.weaviate.v1.VectorsB\020\n\016_is_co" + + "nsistent\"\210\002\n\020PropertiesResult\0223\n\tref_pro" + + "ps\030\002 \003(\0132 .weaviate.v1.RefPropertiesResu" + + "lt\022\031\n\021target_collection\030\003 \001(\t\022-\n\010metadat" + + "a\030\004 \001(\0132\033.weaviate.v1.MetadataResult\022.\n\r" + + "non_ref_props\030\013 \001(\0132\027.weaviate.v1.Proper" + + "ties\022\033\n\023ref_props_requested\030\014 \001(\010J\004\010\001\020\002J" + + "\004\010\005\020\006J\004\010\006\020\007J\004\010\007\020\010J\004\010\010\020\tJ\004\010\t\020\nJ\004\010\n\020\013\"[\n\023R" + + "efPropertiesResult\0221\n\nproperties\030\001 \003(\0132\035" + + ".weaviate.v1.PropertiesResult\022\021\n\tprop_na" + + "me\030\002 \001(\tBG\n-io.weaviate.client6.v1.inter" + + "nal.grpc.protocolB\026WeaviateProtoSearchGe" + + "tb\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.getDescriptor(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.getDescriptor(), + }); + internal_static_weaviate_v1_SearchRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_weaviate_v1_SearchRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_SearchRequest_descriptor, + new java.lang.String[] { "Collection", "Tenant", "ConsistencyLevel", "Properties", "Metadata", "GroupBy", "Limit", "Offset", "Autocut", "After", "SortBy", "Filters", "HybridSearch", "Bm25Search", "NearVector", "NearObject", "NearText", "NearImage", "NearAudio", "NearVideo", "NearDepth", "NearThermal", "NearImu", "Generative", "Rerank", "Uses123Api", "Uses125Api", "Uses127Api", "ConsistencyLevel", "Properties", "Metadata", "GroupBy", "Filters", "HybridSearch", "Bm25Search", "NearVector", "NearObject", "NearText", "NearImage", "NearAudio", "NearVideo", "NearDepth", "NearThermal", "NearImu", "Generative", "Rerank", }); + internal_static_weaviate_v1_GroupBy_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_weaviate_v1_GroupBy_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_GroupBy_descriptor, + new java.lang.String[] { "Path", "NumberOfGroups", "ObjectsPerGroup", }); + internal_static_weaviate_v1_SortBy_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_weaviate_v1_SortBy_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_SortBy_descriptor, + new java.lang.String[] { "Ascending", "Path", }); + internal_static_weaviate_v1_MetadataRequest_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_weaviate_v1_MetadataRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_MetadataRequest_descriptor, + new java.lang.String[] { "Uuid", "Vector", "CreationTimeUnix", "LastUpdateTimeUnix", "Distance", "Certainty", "Score", "ExplainScore", "IsConsistent", "Vectors", }); + internal_static_weaviate_v1_PropertiesRequest_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_weaviate_v1_PropertiesRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_PropertiesRequest_descriptor, + new java.lang.String[] { "NonRefProperties", "RefProperties", "ObjectProperties", "ReturnAllNonrefProperties", }); + internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_weaviate_v1_ObjectPropertiesRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_ObjectPropertiesRequest_descriptor, + new java.lang.String[] { "PropName", "PrimitiveProperties", "ObjectProperties", }); + internal_static_weaviate_v1_RefPropertiesRequest_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_weaviate_v1_RefPropertiesRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_RefPropertiesRequest_descriptor, + new java.lang.String[] { "ReferenceProperty", "Properties", "Metadata", "TargetCollection", }); + internal_static_weaviate_v1_Rerank_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_weaviate_v1_Rerank_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_Rerank_descriptor, + new java.lang.String[] { "Property", "Query", "Query", }); + internal_static_weaviate_v1_SearchReply_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_weaviate_v1_SearchReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_SearchReply_descriptor, + new java.lang.String[] { "Took", "Results", "GenerativeGroupedResult", "GroupByResults", "GenerativeGroupedResults", "GenerativeGroupedResult", "GenerativeGroupedResults", }); + internal_static_weaviate_v1_RerankReply_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_weaviate_v1_RerankReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_RerankReply_descriptor, + new java.lang.String[] { "Score", }); + internal_static_weaviate_v1_GroupByResult_descriptor = + getDescriptor().getMessageTypes().get(10); + internal_static_weaviate_v1_GroupByResult_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_GroupByResult_descriptor, + new java.lang.String[] { "Name", "MinDistance", "MaxDistance", "NumberOfObjects", "Objects", "Rerank", "Generative", "GenerativeResult", "Rerank", "Generative", "GenerativeResult", }); + internal_static_weaviate_v1_SearchResult_descriptor = + getDescriptor().getMessageTypes().get(11); + internal_static_weaviate_v1_SearchResult_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_SearchResult_descriptor, + new java.lang.String[] { "Properties", "Metadata", "Generative", "Generative", }); + internal_static_weaviate_v1_MetadataResult_descriptor = + getDescriptor().getMessageTypes().get(12); + internal_static_weaviate_v1_MetadataResult_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_MetadataResult_descriptor, + new java.lang.String[] { "Id", "Vector", "CreationTimeUnix", "CreationTimeUnixPresent", "LastUpdateTimeUnix", "LastUpdateTimeUnixPresent", "Distance", "DistancePresent", "Certainty", "CertaintyPresent", "Score", "ScorePresent", "ExplainScore", "ExplainScorePresent", "IsConsistent", "Generative", "GenerativePresent", "IsConsistentPresent", "VectorBytes", "IdAsBytes", "RerankScore", "RerankScorePresent", "Vectors", "IsConsistent", }); + internal_static_weaviate_v1_PropertiesResult_descriptor = + getDescriptor().getMessageTypes().get(13); + internal_static_weaviate_v1_PropertiesResult_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_PropertiesResult_descriptor, + new java.lang.String[] { "RefProps", "TargetCollection", "Metadata", "NonRefProps", "RefPropsRequested", }); + internal_static_weaviate_v1_RefPropertiesResult_descriptor = + getDescriptor().getMessageTypes().get(14); + internal_static_weaviate_v1_RefPropertiesResult_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_weaviate_v1_RefPropertiesResult_descriptor, + new java.lang.String[] { "Properties", "PropName", }); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoGenerative.getDescriptor(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoProperties.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoTenants.java b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoTenants.java similarity index 76% rename from src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoTenants.java rename to src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoTenants.java index 02a8a4adf..d4d9d4fcb 100644 --- a/src/main/java/io/weaviate/client/grpc/protocol/v1/WeaviateProtoTenants.java +++ b/src/main/java/io/weaviate/client6/v1/internal/grpc/protocol/WeaviateProtoTenants.java @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! // source: v1/tenants.proto -package io.weaviate.client.grpc.protocol.v1; +package io.weaviate.client6.v1.internal.grpc.protocol; public final class WeaviateProtoTenants { private WeaviateProtoTenants() {} @@ -185,7 +185,7 @@ public TenantActivityStatus findValueByNumber(int number) { } public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.getDescriptor().getEnumTypes().get(0); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.getDescriptor().getEnumTypes().get(0); } private static final TenantActivityStatus[] VALUES = values(); @@ -236,13 +236,13 @@ public interface TenantsGetRequestOrBuilder extends * .weaviate.v1.TenantNames names = 2; * @return The names. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getNames(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getNames(); /** * .weaviate.v1.TenantNames names = 2; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder(); - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.ParamsCase getParamsCase(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.ParamsCase getParamsCase(); } /** * Protobuf type {@code weaviate.v1.TenantsGetRequest} @@ -269,15 +269,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.Builder.class); } private int paramsCase_ = 0; @@ -373,21 +373,21 @@ public boolean hasNames() { * @return The names. */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getNames() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getNames() { if (paramsCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_; + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_; } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } /** * .weaviate.v1.TenantNames names = 2; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder() { if (paramsCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_; + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_; } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } private byte memoizedIsInitialized = -1; @@ -408,7 +408,7 @@ public void writeTo(com.google.protobuf.CodedOutputStream output) com.google.protobuf.GeneratedMessageV3.writeString(output, 1, collection_); } if (paramsCase_ == 2) { - output.writeMessage(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_); + output.writeMessage(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_); } getUnknownFields().writeTo(output); } @@ -424,7 +424,7 @@ public int getSerializedSize() { } if (paramsCase_ == 2) { size += com.google.protobuf.CodedOutputStream - .computeMessageSize(2, (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_); + .computeMessageSize(2, (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_); } size += getUnknownFields().getSerializedSize(); memoizedSize = size; @@ -436,10 +436,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest) obj; if (!getCollection() .equals(other.getCollection())) return false; @@ -478,44 +478,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -523,26 +523,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGe .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -555,7 +555,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGe public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -576,21 +576,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.TenantsGetRequest) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequestOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequestOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.newBuilder() private Builder() { } @@ -616,17 +616,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetRequest_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -634,22 +634,22 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReques } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest(this); if (bitField0_ != 0) { buildPartial0(result); } buildPartialOneofs(result); onBuilt(); return result; } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.collection_ = collection_; } } - private void buildPartialOneofs(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest result) { + private void buildPartialOneofs(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest result) { result.paramsCase_ = paramsCase_; result.params_ = this.params_; if (paramsCase_ == 2 && @@ -692,16 +692,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest.getDefaultInstance()) return this; if (!other.getCollection().isEmpty()) { collection_ = other.collection_; bitField0_ |= 0x00000001; @@ -859,7 +859,7 @@ public Builder setCollectionBytes( } private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder> namesBuilder_; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder> namesBuilder_; /** * .weaviate.v1.TenantNames names = 2; * @return Whether the names field is set. @@ -873,23 +873,23 @@ public boolean hasNames() { * @return The names. */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getNames() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getNames() { if (namesBuilder_ == null) { if (paramsCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_; + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_; } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } else { if (paramsCase_ == 2) { return namesBuilder_.getMessage(); } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } } /** * .weaviate.v1.TenantNames names = 2; */ - public Builder setNames(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames value) { + public Builder setNames(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames value) { if (namesBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -906,7 +906,7 @@ public Builder setNames(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants * .weaviate.v1.TenantNames names = 2; */ public Builder setNames( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder builderForValue) { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder builderForValue) { if (namesBuilder_ == null) { params_ = builderForValue.build(); onChanged(); @@ -919,11 +919,11 @@ public Builder setNames( /** * .weaviate.v1.TenantNames names = 2; */ - public Builder mergeNames(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames value) { + public Builder mergeNames(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames value) { if (namesBuilder_ == null) { if (paramsCase_ == 2 && - params_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance()) { - params_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.newBuilder((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_) + params_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance()) { + params_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.newBuilder((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_) .mergeFrom(value).buildPartial(); } else { params_ = value; @@ -961,36 +961,36 @@ public Builder clearNames() { /** * .weaviate.v1.TenantNames names = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder getNamesBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder getNamesBuilder() { return getNamesFieldBuilder().getBuilder(); } /** * .weaviate.v1.TenantNames names = 2; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder getNamesOrBuilder() { if ((paramsCase_ == 2) && (namesBuilder_ != null)) { return namesBuilder_.getMessageOrBuilder(); } else { if (paramsCase_ == 2) { - return (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_; + return (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_; } - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } } /** * .weaviate.v1.TenantNames names = 2; */ private com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder> + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder> getNamesFieldBuilder() { if (namesBuilder_ == null) { if (!(paramsCase_ == 2)) { - params_ = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + params_ = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } namesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder>( - (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) params_, + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder>( + (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) params_, getParentForChildren(), isClean()); params_ = null; @@ -1016,12 +1016,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.TenantsGetRequest) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -1057,7 +1057,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetRequest getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetRequest getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -1118,15 +1118,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder.class); } public static final int VALUES_FIELD_NUMBER = 1; @@ -1210,10 +1210,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) obj; if (!getValuesList() .equals(other.getValuesList())) return false; @@ -1237,44 +1237,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1282,26 +1282,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNam .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1314,7 +1314,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNam public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -1335,21 +1335,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.TenantNames) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNamesOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNamesOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.newBuilder() private Builder() { } @@ -1371,17 +1371,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantNames_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -1389,14 +1389,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames buil } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames(this); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { values_.makeImmutable(); @@ -1438,16 +1438,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames.getDefaultInstance()) return this; if (!other.values_.isEmpty()) { if (values_.isEmpty()) { values_ = other.values_; @@ -1634,12 +1634,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.TenantNames) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -1675,7 +1675,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantNames getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -1694,12 +1694,12 @@ public interface TenantsGetReplyOrBuilder extends /** * repeated .weaviate.v1.Tenant tenants = 2; */ - java.util.List + java.util.List getTenantsList(); /** * repeated .weaviate.v1.Tenant tenants = 2; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getTenants(int index); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getTenants(int index); /** * repeated .weaviate.v1.Tenant tenants = 2; */ @@ -1707,12 +1707,12 @@ public interface TenantsGetReplyOrBuilder extends /** * repeated .weaviate.v1.Tenant tenants = 2; */ - java.util.List + java.util.List getTenantsOrBuilderList(); /** * repeated .weaviate.v1.Tenant tenants = 2; */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( int index); } /** @@ -1740,15 +1740,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.Builder.class); } public static final int TOOK_FIELD_NUMBER = 1; @@ -1764,19 +1764,19 @@ public float getTook() { public static final int TENANTS_FIELD_NUMBER = 2; @SuppressWarnings("serial") - private java.util.List tenants_; + private java.util.List tenants_; /** * repeated .weaviate.v1.Tenant tenants = 2; */ @java.lang.Override - public java.util.List getTenantsList() { + public java.util.List getTenantsList() { return tenants_; } /** * repeated .weaviate.v1.Tenant tenants = 2; */ @java.lang.Override - public java.util.List + public java.util.List getTenantsOrBuilderList() { return tenants_; } @@ -1791,14 +1791,14 @@ public int getTenantsCount() { * repeated .weaviate.v1.Tenant tenants = 2; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getTenants(int index) { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getTenants(int index) { return tenants_.get(index); } /** * repeated .weaviate.v1.Tenant tenants = 2; */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( int index) { return tenants_.get(index); } @@ -1850,10 +1850,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply) obj; if (java.lang.Float.floatToIntBits(getTook()) != java.lang.Float.floatToIntBits( @@ -1883,44 +1883,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1928,26 +1928,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGe .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -1960,7 +1960,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGe public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -1981,21 +1981,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.TenantsGetReply) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReplyOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReplyOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.newBuilder() private Builder() { } @@ -2023,17 +2023,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_TenantsGetReply_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -2041,15 +2041,15 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply(this); buildPartialRepeatedFields(result); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply result) { + private void buildPartialRepeatedFields(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply result) { if (tenantsBuilder_ == null) { if (((bitField0_ & 0x00000002) != 0)) { tenants_ = java.util.Collections.unmodifiableList(tenants_); @@ -2061,7 +2061,7 @@ private void buildPartialRepeatedFields(io.weaviate.client.grpc.protocol.v1.Weav } } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.took_ = took_; @@ -2102,16 +2102,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply.getDefaultInstance()) return this; if (other.getTook() != 0F) { setTook(other.getTook()); } @@ -2173,9 +2173,9 @@ public Builder mergeFrom( break; } // case 13 case 18: { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant m = + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant m = input.readMessage( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.parser(), + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.parser(), extensionRegistry); if (tenantsBuilder_ == null) { ensureTenantsIsMutable(); @@ -2234,22 +2234,22 @@ public Builder clearTook() { return this; } - private java.util.List tenants_ = + private java.util.List tenants_ = java.util.Collections.emptyList(); private void ensureTenantsIsMutable() { if (!((bitField0_ & 0x00000002) != 0)) { - tenants_ = new java.util.ArrayList(tenants_); + tenants_ = new java.util.ArrayList(tenants_); bitField0_ |= 0x00000002; } } private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder> tenantsBuilder_; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder> tenantsBuilder_; /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public java.util.List getTenantsList() { + public java.util.List getTenantsList() { if (tenantsBuilder_ == null) { return java.util.Collections.unmodifiableList(tenants_); } else { @@ -2269,7 +2269,7 @@ public int getTenantsCount() { /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getTenants(int index) { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getTenants(int index) { if (tenantsBuilder_ == null) { return tenants_.get(index); } else { @@ -2280,7 +2280,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getTenant * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder setTenants( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant value) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant value) { if (tenantsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2297,7 +2297,7 @@ public Builder setTenants( * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder setTenants( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder builderForValue) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder builderForValue) { if (tenantsBuilder_ == null) { ensureTenantsIsMutable(); tenants_.set(index, builderForValue.build()); @@ -2310,7 +2310,7 @@ public Builder setTenants( /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public Builder addTenants(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant value) { + public Builder addTenants(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant value) { if (tenantsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2327,7 +2327,7 @@ public Builder addTenants(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenan * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder addTenants( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant value) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant value) { if (tenantsBuilder_ == null) { if (value == null) { throw new NullPointerException(); @@ -2344,7 +2344,7 @@ public Builder addTenants( * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder addTenants( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder builderForValue) { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder builderForValue) { if (tenantsBuilder_ == null) { ensureTenantsIsMutable(); tenants_.add(builderForValue.build()); @@ -2358,7 +2358,7 @@ public Builder addTenants( * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder addTenants( - int index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder builderForValue) { + int index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder builderForValue) { if (tenantsBuilder_ == null) { ensureTenantsIsMutable(); tenants_.add(index, builderForValue.build()); @@ -2372,7 +2372,7 @@ public Builder addTenants( * repeated .weaviate.v1.Tenant tenants = 2; */ public Builder addAllTenants( - java.lang.Iterable values) { + java.lang.Iterable values) { if (tenantsBuilder_ == null) { ensureTenantsIsMutable(); com.google.protobuf.AbstractMessageLite.Builder.addAll( @@ -2412,14 +2412,14 @@ public Builder removeTenants(int index) { /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder getTenantsBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder getTenantsBuilder( int index) { return getTenantsFieldBuilder().getBuilder(index); } /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder getTenantsOrBuilder( int index) { if (tenantsBuilder_ == null) { return tenants_.get(index); } else { @@ -2429,7 +2429,7 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public java.util.List + public java.util.List getTenantsOrBuilderList() { if (tenantsBuilder_ != null) { return tenantsBuilder_.getMessageOrBuilderList(); @@ -2440,31 +2440,31 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder addTenantsBuilder() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder addTenantsBuilder() { return getTenantsFieldBuilder().addBuilder( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.getDefaultInstance()); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.getDefaultInstance()); } /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder addTenantsBuilder( + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder addTenantsBuilder( int index) { return getTenantsFieldBuilder().addBuilder( - index, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.getDefaultInstance()); + index, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.getDefaultInstance()); } /** * repeated .weaviate.v1.Tenant tenants = 2; */ - public java.util.List + public java.util.List getTenantsBuilderList() { return getTenantsFieldBuilder().getBuilderList(); } private com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder> + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder> getTenantsFieldBuilder() { if (tenantsBuilder_ == null) { tenantsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder>( + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder>( tenants_, ((bitField0_ & 0x00000002) != 0), getParentForChildren(), @@ -2490,12 +2490,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.TenantsGetReply) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -2531,7 +2531,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantsGetReply getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantsGetReply getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -2562,7 +2562,7 @@ public interface TenantOrBuilder extends * .weaviate.v1.TenantActivityStatus activity_status = 2; * @return The activityStatus. */ - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus getActivityStatus(); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus getActivityStatus(); } /** * Protobuf type {@code weaviate.v1.Tenant} @@ -2590,15 +2590,15 @@ protected java.lang.Object newInstance( public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder.class); } public static final int NAME_FIELD_NUMBER = 1; @@ -2653,9 +2653,9 @@ public java.lang.String getName() { * .weaviate.v1.TenantActivityStatus activity_status = 2; * @return The activityStatus. */ - @java.lang.Override public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus getActivityStatus() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.forNumber(activityStatus_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.UNRECOGNIZED : result; + @java.lang.Override public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus getActivityStatus() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.forNumber(activityStatus_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.UNRECOGNIZED : result; } private byte memoizedIsInitialized = -1; @@ -2675,7 +2675,7 @@ public void writeTo(com.google.protobuf.CodedOutputStream output) if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); } - if (activityStatus_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.TENANT_ACTIVITY_STATUS_UNSPECIFIED.getNumber()) { + if (activityStatus_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.TENANT_ACTIVITY_STATUS_UNSPECIFIED.getNumber()) { output.writeEnum(2, activityStatus_); } getUnknownFields().writeTo(output); @@ -2690,7 +2690,7 @@ public int getSerializedSize() { if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); } - if (activityStatus_ != io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.TENANT_ACTIVITY_STATUS_UNSPECIFIED.getNumber()) { + if (activityStatus_ != io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.TENANT_ACTIVITY_STATUS_UNSPECIFIED.getNumber()) { size += com.google.protobuf.CodedOutputStream .computeEnumSize(2, activityStatus_); } @@ -2704,10 +2704,10 @@ public boolean equals(final java.lang.Object obj) { if (obj == this) { return true; } - if (!(obj instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant)) { + if (!(obj instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant)) { return super.equals(obj); } - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant other = (io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant) obj; + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant other = (io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant) obj; if (!getName() .equals(other.getName())) return false; @@ -2732,44 +2732,44 @@ public int hashCode() { return hash; } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom(byte[] data) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -2777,26 +2777,26 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant pa .parseWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseDelimitedFrom(java.io.InputStream input) + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseDelimitedFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3 .parseWithIOException(PARSER, input); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant parseFrom( + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { @@ -2809,7 +2809,7 @@ public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant pa public static Builder newBuilder() { return DEFAULT_INSTANCE.toBuilder(); } - public static Builder newBuilder(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant prototype) { + public static Builder newBuilder(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant prototype) { return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); } @java.lang.Override @@ -2830,21 +2830,21 @@ protected Builder newBuilderForType( public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:weaviate.v1.Tenant) - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantOrBuilder { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; } @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_fieldAccessorTable + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_fieldAccessorTable .ensureFieldAccessorsInitialized( - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.class, io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.Builder.class); + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.class, io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.Builder.class); } - // Construct using io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.newBuilder() + // Construct using io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.newBuilder() private Builder() { } @@ -2866,17 +2866,17 @@ public Builder clear() { @java.lang.Override public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.internal_static_weaviate_v1_Tenant_descriptor; } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getDefaultInstanceForType() { - return io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.getDefaultInstance(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getDefaultInstanceForType() { + return io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.getDefaultInstance(); } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant build() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant result = buildPartial(); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant build() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant result = buildPartial(); if (!result.isInitialized()) { throw newUninitializedMessageException(result); } @@ -2884,14 +2884,14 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant build() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant buildPartial() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant result = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant(this); + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant buildPartial() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant result = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant(this); if (bitField0_ != 0) { buildPartial0(result); } onBuilt(); return result; } - private void buildPartial0(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant result) { + private void buildPartial0(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant result) { int from_bitField0_ = bitField0_; if (((from_bitField0_ & 0x00000001) != 0)) { result.name_ = name_; @@ -2935,16 +2935,16 @@ public Builder addRepeatedField( } @java.lang.Override public Builder mergeFrom(com.google.protobuf.Message other) { - if (other instanceof io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant) { - return mergeFrom((io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant)other); + if (other instanceof io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant) { + return mergeFrom((io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant)other); } else { super.mergeFrom(other); return this; } } - public Builder mergeFrom(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant other) { - if (other == io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant.getDefaultInstance()) return this; + public Builder mergeFrom(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant other) { + if (other == io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant.getDefaultInstance()) return this; if (!other.getName().isEmpty()) { name_ = other.name_; bitField0_ |= 0x00000001; @@ -3102,16 +3102,16 @@ public Builder setActivityStatusValue(int value) { * @return The activityStatus. */ @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus getActivityStatus() { - io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus result = io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.forNumber(activityStatus_); - return result == null ? io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus.UNRECOGNIZED : result; + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus getActivityStatus() { + io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus result = io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.forNumber(activityStatus_); + return result == null ? io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus.UNRECOGNIZED : result; } /** * .weaviate.v1.TenantActivityStatus activity_status = 2; * @param value The activityStatus to set. * @return This builder for chaining. */ - public Builder setActivityStatus(io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.TenantActivityStatus value) { + public Builder setActivityStatus(io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantActivityStatus value) { if (value == null) { throw new NullPointerException(); } @@ -3147,12 +3147,12 @@ public final Builder mergeUnknownFields( } // @@protoc_insertion_point(class_scope:weaviate.v1.Tenant) - private static final io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant DEFAULT_INSTANCE; + private static final io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant DEFAULT_INSTANCE; static { - DEFAULT_INSTANCE = new io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant(); + DEFAULT_INSTANCE = new io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant(); } - public static io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getDefaultInstance() { + public static io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getDefaultInstance() { return DEFAULT_INSTANCE; } @@ -3188,7 +3188,7 @@ public com.google.protobuf.Parser getParserForType() { } @java.lang.Override - public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getDefaultInstanceForType() { + public io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.Tenant getDefaultInstanceForType() { return DEFAULT_INSTANCE; } @@ -3241,10 +3241,9 @@ public io.weaviate.client.grpc.protocol.v1.WeaviateProtoTenants.Tenant getDefaul "TIVITY_STATUS_INACTIVE\020\010\022$\n TENANT_ACTIV" + "ITY_STATUS_OFFLOADED\020\t\022%\n!TENANT_ACTIVIT" + "Y_STATUS_OFFLOADING\020\n\022$\n TENANT_ACTIVITY" + - "_STATUS_ONLOADING\020\013\"\004\010\003\020\003Bq\n#io.weaviate" + - ".client.grpc.protocol.v1B\024WeaviateProtoT" + - "enantsZ4github.com/weaviate/weaviate/grp" + - "c/generated;protocolb\006proto3" + "_STATUS_ONLOADING\020\013\"\004\010\003\020\003BE\n-io.weaviate" + + ".client6.v1.internal.grpc.protocolB\024Weav" + + "iateProtoTenantsb\006proto3" }; descriptor = com.google.protobuf.Descriptors.FileDescriptor .internalBuildGeneratedFileFrom(descriptorData, diff --git a/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java b/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java new file mode 100644 index 000000000..85bf428bc --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java @@ -0,0 +1,111 @@ +package io.weaviate.client6.v1.internal.json; + +import java.util.List; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import com.google.gson.ToNumberPolicy; +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.internal.orm.PropertyFieldNamingStrategy; + +public final class JSON { + private static final Gson gson; + + static { + var gsonBuilder = new GsonBuilder(); + + // TypeAdapterFactories --------------------------------------------------- + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.rbac.Permission.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.rbac.Role.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.WeaviateObject.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.CollectionConfig.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.Vectors.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.VectorConfig.CustomTypeAdapterFactory.INSTANCE); + + // These 2 adapters need to be registered in this exact order: Dynamic + // (narrower), VectorIndex (broader). + // When searching for an adapter, Gson will pick the first adapter factory that + // can process the class, and it's important that Dynamic.class is processed by + // this factory. + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.vectorindex.Dynamic.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.VectorIndex.CustomTypeAdapterFactory.INSTANCE); + + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.Reranker.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.Generative.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.Quantization.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.vectorindex.MultiVector.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.api.collections.Encoding.CustomTypeAdapterFactory.INSTANCE); + gsonBuilder.registerTypeAdapterFactory( + io.weaviate.client6.v1.internal.DateUtil.CustomTypeAdapterFactory.INSTANCE); + + // TypeAdapters ----------------------------------------------------------- + gsonBuilder.registerTypeAdapter( + io.weaviate.client6.v1.api.collections.data.ObjectReference.class, + io.weaviate.client6.v1.api.collections.data.ObjectReference.TYPE_ADAPTER); + gsonBuilder.registerTypeAdapter( + io.weaviate.client6.v1.api.collections.Reference.class, + io.weaviate.client6.v1.api.collections.data.ObjectReference.TYPE_ADAPTER); + gsonBuilder.registerTypeAdapter( + io.weaviate.client6.v1.api.collections.data.BatchReference.class, + io.weaviate.client6.v1.api.collections.data.BatchReference.TYPE_ADAPTER); + + // Deserilizers ----------------------------------------------------------- + gsonBuilder.registerTypeAdapter( + io.weaviate.client6.v1.api.collections.data.ReferenceAddManyResponse.class, + io.weaviate.client6.v1.api.collections.data.ReferenceAddManyResponse.CustomJsonDeserializer.INSTANCE); + + // ORM FieldNaminsStrategy ------------------------------------------------ + gsonBuilder.setFieldNamingStrategy(PropertyFieldNamingStrategy.INSTANCE); + + gsonBuilder.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE); + gson = gsonBuilder.create(); + } + + public static final Gson getGson() { + return gson; + } + + public static final String serialize(Object value) { + if (value == null) { + return null; + } + return serialize(value, TypeToken.get(value.getClass())); + } + + public static final JsonElement toJsonElement(String json) { + return JsonParser.parseString(json); + } + + public static final String serialize(Object value, TypeToken typeToken) { + return gson.toJson(value, typeToken.getType()); + } + + public static final T deserialize(String json, Class cls) { + return gson.fromJson(json, cls); + } + + @SuppressWarnings("unchecked") + public static final List deserializeList(String json, Class cls) { + return (List) deserialize(json, TypeToken.getParameterized(List.class, cls)); + } + + public static final T deserialize(String json, TypeToken token) { + return gson.fromJson(json, token); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/json/JsonEnum.java b/src/main/java/io/weaviate/client6/v1/internal/json/JsonEnum.java new file mode 100644 index 000000000..c68a64892 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/json/JsonEnum.java @@ -0,0 +1,26 @@ +package io.weaviate.client6.v1.internal.json; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +public interface JsonEnum> { + String jsonValue(); + + static > Map collectNames(JsonEnum[] values) { + final var jsonValueMap = new HashMap(values.length); + for (var value : values) { + @SuppressWarnings("unchecked") + var enumInstance = (E) value; + jsonValueMap.put(value.jsonValue(), enumInstance); + } + return Collections.unmodifiableMap(jsonValueMap); + } + + static > E valueOfJson(String jsonValue, Map enums, Class cls) { + if (!enums.containsKey(jsonValue)) { + throw new IllegalArgumentException("%s does not have a member with jsonValue=%s".formatted(cls, jsonValue)); + } + return enums.get(jsonValue); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcConfig.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcConfig.java new file mode 100644 index 000000000..858fd4d82 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcConfig.java @@ -0,0 +1,36 @@ +package io.weaviate.client6.v1.internal.oidc; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public record OidcConfig( + String clientId, + String providerMetadata, + Set scopes) { + + public OidcConfig(String clientId, String providerMetadata, Set scopes) { + this.clientId = clientId; + this.providerMetadata = providerMetadata; + this.scopes = scopes != null ? Set.copyOf(scopes) : Collections.emptySet(); + } + + public OidcConfig(String clientId, String providerMetadata, List scopes) { + this(clientId, providerMetadata, scopes == null ? null : new HashSet<>(scopes)); + } + + /** Create a new OIDC config with extended scopes. */ + public OidcConfig withScopes(String... scopes) { + return withScopes(Arrays.asList(scopes)); + } + + /** Create a new OIDC config with extended scopes. */ + public OidcConfig withScopes(List scopes) { + var newScopes = Stream.concat(this.scopes.stream(), scopes.stream()).collect(Collectors.toSet()); + return new OidcConfig(clientId, providerMetadata, newScopes); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcUtils.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcUtils.java new file mode 100644 index 000000000..cafcc1289 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/OidcUtils.java @@ -0,0 +1,59 @@ +package io.weaviate.client6.v1.internal.oidc; + +import java.io.IOException; +import java.util.Collections; +import java.util.List; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.api.WeaviateOAuthException; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.ExternalEndpoint; +import io.weaviate.client6.v1.internal.rest.RestTransport; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public final class OidcUtils { + /** Prevents public initialization. */ + private OidcUtils() { + } + + private static final String OPENID_CONFIGURATION_URL = "/.well-known/openid-configuration"; + + private static final Endpoint GET_OPENID_ENDPOINT = SimpleEndpoint.noBody( + request -> "GET", + request -> OPENID_CONFIGURATION_URL, + request -> Collections.emptyMap(), + OpenIdConfiguration.class); + + private static final Endpoint GET_PROVIDER_METADATA_ENDPOINT = new ExternalEndpoint<>( + request -> "GET", + request -> request, // URL is the request body. + requesf -> Collections.emptyMap(), + request -> null, + (__, response) -> response); + + private static record OpenIdConfiguration( + @SerializedName("clientId") String clientId, + @SerializedName("scopes") List scopes, + @SerializedName("href") String endpoint) { + } + + /** Fetch cluster's OIDC config. */ + public static final OidcConfig getConfig(RestTransport transport) { + OpenIdConfiguration openid; + try { + openid = transport.performRequest(null, GET_OPENID_ENDPOINT); + } catch (IOException e) { + throw new WeaviateOAuthException("fetch OpenID configuration", e); + } + + String providerMetadata; + try { + providerMetadata = transport.performRequest(openid.endpoint(), GET_PROVIDER_METADATA_ENDPOINT); + } catch (IOException e) { + throw new WeaviateOAuthException("fetch provider metadata", e); + } + + return new OidcConfig(openid.clientId(), providerMetadata, openid.scopes()); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/Flow.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/Flow.java new file mode 100644 index 000000000..ad12561ff --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/Flow.java @@ -0,0 +1,45 @@ +package io.weaviate.client6.v1.internal.oidc.nimbus; + +import com.nimbusds.oauth2.sdk.AuthorizationGrant; +import com.nimbusds.oauth2.sdk.ClientCredentialsGrant; +import com.nimbusds.oauth2.sdk.ResourceOwnerPasswordCredentialsGrant; +import com.nimbusds.oauth2.sdk.auth.ClientAuthentication; +import com.nimbusds.oauth2.sdk.auth.ClientSecretPost; +import com.nimbusds.oauth2.sdk.auth.Secret; +import com.nimbusds.oauth2.sdk.id.ClientID; + +import io.weaviate.client6.v1.internal.TokenProvider.Token; + +@FunctionalInterface +interface Flow { + AuthorizationGrant getAuthorizationGrant(); + + default ClientAuthentication getClientAuthentication() { + return null; + } + + static Flow refreshToken(Token t) { + return new RefreshTokenFlow(t); + } + + static Flow resourceOwnerPassword(String username, String password) { + final var grant = new ResourceOwnerPasswordCredentialsGrant(username, new Secret(password)); + return () -> grant; // Reuse cached authorization grant + } + + static Flow clientCredentials(String clientId, String clientSecret) { + return new Flow() { + private static final AuthorizationGrant GRANT = new ClientCredentialsGrant(); + + @Override + public AuthorizationGrant getAuthorizationGrant() { + return GRANT; + } + + @Override + public ClientAuthentication getClientAuthentication() { + return new ClientSecretPost(new ClientID(clientId), new Secret(clientSecret)); + } + }; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/HttpResponseParser.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/HttpResponseParser.java new file mode 100644 index 000000000..3c7f70436 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/HttpResponseParser.java @@ -0,0 +1,79 @@ +package io.weaviate.client6.v1.internal.oidc.nimbus; + +import com.google.gson.annotations.SerializedName; +import com.nimbusds.oauth2.sdk.ErrorResponse; +import com.nimbusds.oauth2.sdk.ParseException; +import com.nimbusds.oauth2.sdk.TokenResponse; +import com.nimbusds.oauth2.sdk.http.HTTPResponse; +import com.nimbusds.openid.connect.sdk.OIDCTokenResponse; +import com.nimbusds.openid.connect.sdk.OIDCTokenResponseParser; +import com.nimbusds.openid.connect.sdk.token.OIDCTokens; + +import io.weaviate.client6.v1.api.WeaviateOAuthException; +import io.weaviate.client6.v1.internal.json.JSON; + +final class OIDCTokensParser { + /** + * Prevents public instantiation. + */ + private OIDCTokensParser() { + } + + /** + * Parse HTTP response containing a new set of OIDC tokens (access_token and + * refresh_token). + * + *

+ * Nimbus expects the following format of an error response, as per RFC 6749: + * + *

+   *  {
+   *    "error_code": "invalid_client",
+   *    "error_description": "Invalid value for 'client_id' parameter."
+   *  }
+   * 
+ * + * Unfortunately, not all OIDC servers adhere to it. E.g. Okta returns + * {@code "errorCode"} and {@code "errorSummary"}, which Nimbus's + * {@link OIDCTokenResponseParser} fails to parse. In order to get a meaningful + * error message we make a second pass in case error details are incomplete + * after the first pass. + * + * @throws ParseException if {@link OIDCTokenResponseParser#parse()} + * failed. + * @throws WeaviateOAuthException if response indicates error. As determined by + * {@link TokenResponse#indicatesSuccess()}. + */ + static OIDCTokens parse(HTTPResponse httpResponse) throws ParseException { + var response = OIDCTokenResponseParser.parse(httpResponse); + if (response.indicatesSuccess()) { + return ((OIDCTokenResponse) response).getOIDCTokens(); + } + + var error = fromErrorResponse(response.toErrorResponse()); + if (!error.isComplete()) { + error = fromHttpResponse(httpResponse); + } + throw new WeaviateOAuthException("%s (code=%s)".formatted( + error.description(), + error.code())); + } + + private static record ErrorDetails( + @SerializedName("errorCode") String code, + @SerializedName("errorSummary") String description) { + + private boolean isComplete() { + return code != null && description != null; + } + } + + private static ErrorDetails fromErrorResponse(ErrorResponse response) { + var err = response.getErrorObject(); + return new ErrorDetails(err.getCode(), err.getDescription()); + } + + private static ErrorDetails fromHttpResponse(HTTPResponse response) { + return JSON.deserialize(response.getBody(), ErrorDetails.class); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/NimbusTokenProvider.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/NimbusTokenProvider.java new file mode 100644 index 000000000..4bef50e71 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/NimbusTokenProvider.java @@ -0,0 +1,126 @@ +package io.weaviate.client6.v1.internal.oidc.nimbus; + +import java.io.IOException; + +import javax.annotation.concurrent.NotThreadSafe; + +import com.nimbusds.oauth2.sdk.ParseException; +import com.nimbusds.oauth2.sdk.Scope; +import com.nimbusds.oauth2.sdk.TokenRequest; +import com.nimbusds.oauth2.sdk.id.ClientID; +import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata; +import com.nimbusds.openid.connect.sdk.token.OIDCTokens; + +import io.weaviate.client6.v1.api.WeaviateOAuthException; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.oidc.OidcConfig; + +@NotThreadSafe +public final class NimbusTokenProvider implements TokenProvider { + private final OIDCProviderMetadata metadata; + private final ClientID clientId; + private final Scope scope; + private final Flow flow; + + /** + * Create a TokenProvider that uses Refresh Token authorization grant. + * + * @param oidc OIDC config. + * @param t Current token. Must not be null. + * + * @return A new instance of NimbusTokenProvider. Instances are never cached. + * @throws WeaviateOAuthException if an error occurred at any point of the + * exchange process. + */ + public static NimbusTokenProvider refreshToken(OidcConfig oidc, Token t) { + return new NimbusTokenProvider(oidc, Flow.refreshToken(t)); + } + + /** + * Create a TokenProvider that uses Resource Owner Password authorization grant. + * + * @param oidc OIDC config. + * @param username Resource owner username. + * @param password Resource owner password. + * + * @return A new instance of NimbusTokenProvider. Instances are never cached. + * @throws WeaviateOAuthException if an error occured at any point of the + * exchange process. + */ + public static NimbusTokenProvider resourceOwnerPassword(OidcConfig oidc, String username, String password) { + return new NimbusTokenProvider(oidc, Flow.resourceOwnerPassword(username, password)); + } + + /** + * Create a TokenProvider that uses Client Credentials authorization grant. + * + * @param oidc OIDC config. + * @param clientSecret Client secret. + * + * @return A new instance of NimbusTokenProvider. Instances are never cached. + * @throws WeaviateOAuthException if an error occured at any point of the + * exchange process. + */ + public static NimbusTokenProvider clientCredentials(OidcConfig oidc, String clientSecret) { + return new NimbusTokenProvider(oidc, Flow.clientCredentials(oidc.clientId(), clientSecret)); + } + + private NimbusTokenProvider(OidcConfig oidc, Flow flow) { + this.metadata = _parseProviderMetadata(oidc.providerMetadata()); + this.clientId = new ClientID(oidc.clientId()); + this.scope = new Scope(oidc.scopes().toArray(String[]::new)); + this.flow = flow; + } + + @Override + public Token getToken() { + var uri = metadata.getTokenEndpointURI(); + var grant = flow.getAuthorizationGrant(); + + var clientAuth = flow.getClientAuthentication(); + var tokenRequest = clientAuth == null + ? new TokenRequest(uri, clientId, grant, scope) + : new TokenRequest(uri, clientAuth, grant, scope); + var request = tokenRequest.toHTTPRequest(); + + OIDCTokens tokens; + try { + var response = request.send(); + tokens = OIDCTokensParser.parse(response); + } catch (IOException | ParseException e) { + throw new WeaviateOAuthException(e); + } + + var accessToken = tokens.getAccessToken(); + var refreshToken = tokens.getRefreshToken(); + + var newToken = refreshToken == null + ? Token.expireAfter(accessToken.getValue(), accessToken.getLifetime()) + : Token.expireAfter(accessToken.getValue(), refreshToken.getValue(), accessToken.getLifetime()); + + if (flow instanceof RefreshTokenFlow rtf) { + // Some IdP servers may omit refresh_token from the response if it is + // sufficiently long-lived. In such case we continue reusing the old one. + if (newToken.refreshToken() == null) { + var rt = rtf.getRefreshToken(); + newToken = newToken.withRefreshToken(rt); + } + rtf.setToken(newToken); + } + + return newToken; + } + + public static ProviderMetadata parseProviderMetadata(String providerMetadata) { + var metadata = _parseProviderMetadata(providerMetadata); + return new ProviderMetadata(metadata.getTokenEndpointURI()); + } + + private static OIDCProviderMetadata _parseProviderMetadata(String providerMetadata) { + try { + return OIDCProviderMetadata.parse(providerMetadata); + } catch (ParseException ex) { + throw new WeaviateOAuthException("parse provider metadata: ", ex); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/RefreshTokenFlow.java b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/RefreshTokenFlow.java new file mode 100644 index 000000000..ce7e18df3 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/oidc/nimbus/RefreshTokenFlow.java @@ -0,0 +1,37 @@ +package io.weaviate.client6.v1.internal.oidc.nimbus; + +import javax.annotation.concurrent.NotThreadSafe; + +import com.nimbusds.oauth2.sdk.AuthorizationGrant; +import com.nimbusds.oauth2.sdk.RefreshTokenGrant; +import com.nimbusds.oauth2.sdk.token.RefreshToken; + +import io.weaviate.client6.v1.internal.TokenProvider.Token; + +/** + * RefreshTokenFlow provides {@link RefreshTokenGrant} with a refresh_token. + * Once the caller has obtained a new {@link Token} it must be updated using + * {@link #setToken} to ensure RefreshTokenFlow continues to return valid + * authorization grants. + */ +@NotThreadSafe +final class RefreshTokenFlow implements Flow { + private Token t; + + RefreshTokenFlow(Token t) { + this.t = t; + } + + @Override + public AuthorizationGrant getAuthorizationGrant() { + return new RefreshTokenGrant(new RefreshToken(t.refreshToken())); + } + + public String getRefreshToken() { + return t.refreshToken(); + } + + public void setToken(Token t) { + this.t = t; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/CollectionDescriptor.java b/src/main/java/io/weaviate/client6/v1/internal/orm/CollectionDescriptor.java new file mode 100644 index 000000000..de7ca31a0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/CollectionDescriptor.java @@ -0,0 +1,31 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.util.Map; +import java.util.function.Function; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +public sealed interface CollectionDescriptor permits MapDescriptor, PojoDescriptor { + String collectionName(); + + TypeToken typeToken(); + + PropertiesReader propertiesReader(PropertiesT properties); + + PropertiesBuilder propertiesBuilder(); + + default Function> configFn() { + return ObjectBuilder.identity(); + } + + static CollectionDescriptor> ofMap(String collectionName) { + return new MapDescriptor(collectionName); + } + + static CollectionDescriptor ofClass(Class cls) { + return new PojoDescriptor<>(cls); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/MapBuilder.java b/src/main/java/io/weaviate/client6/v1/internal/orm/MapBuilder.java new file mode 100644 index 000000000..7e76fa9f8 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/MapBuilder.java @@ -0,0 +1,109 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.time.OffsetDateTime; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; + +public class MapBuilder implements PropertiesBuilder> { + private final Map properties = new HashMap<>(); + + @Override + public void setNull(String property) { + properties.put(property, null); + } + + @Override + public void setText(String property, String value) { + properties.put(property, value); + } + + @Override + public void setBoolean(String property, Boolean value) { + properties.put(property, value); + } + + @Override + public void setLong(String property, Long value) { + properties.put(property, value); + } + + @Override + public void setDouble(String property, Double value) { + properties.put(property, value); + } + + @Override + public void setBlob(String property, String value) { + properties.put(property, value); + } + + @Override + public void setOffsetDateTime(String property, OffsetDateTime value) { + properties.put(property, value); + } + + @Override + public void setUuid(String property, UUID value) { + properties.put(property, value); + } + + @Override + public void setTextArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setLongArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setDoubleArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setUuidArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setBooleanArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setOffsetDateTimeArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setNestedObject(String property, Object value) { + properties.put(property, value); + } + + @Override + public void setNestedObjectArray(String property, List value) { + properties.put(property, value); + } + + @Override + public void setPhoneNumber(String property, PhoneNumber value) { + properties.put(property, value); + } + + @Override + public void setGeoCoordinates(String property, GeoCoordinates value) { + properties.put(property, value); + } + + @Override + public Map build() { + return new HashMap<>(properties); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/MapDescriptor.java b/src/main/java/io/weaviate/client6/v1/internal/orm/MapDescriptor.java new file mode 100644 index 000000000..1d7549a76 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/MapDescriptor.java @@ -0,0 +1,34 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.util.Map; + +import com.google.gson.reflect.TypeToken; + +public final class MapDescriptor implements CollectionDescriptor> { + private final String collectionName; + + public MapDescriptor(String collectionName) { + this.collectionName = collectionName; + } + + @Override + public String collectionName() { + return collectionName; + } + + @Override + public PropertiesReader> propertiesReader(Map properties) { + return new MapReader(properties); + } + + @Override + public PropertiesBuilder> propertiesBuilder() { + return new MapBuilder(); + } + + @SuppressWarnings("unchecked") + @Override + public TypeToken> typeToken() { + return (TypeToken>) TypeToken.getParameterized(Map.class, String.class, Object.class); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/MapReader.java b/src/main/java/io/weaviate/client6/v1/internal/orm/MapReader.java new file mode 100644 index 000000000..004eb0a4d --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/MapReader.java @@ -0,0 +1,19 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +public class MapReader implements PropertiesReader> { + private final Map properties; + + public MapReader(Map properties) { + // Defensive copy to ensure original properties are not modified + this.properties = Collections.unmodifiableMap(new HashMap<>(properties)); + } + + @Override + public Map readProperties() { + return properties; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PojoBuilder.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoBuilder.java new file mode 100644 index 000000000..e5d08972b --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoBuilder.java @@ -0,0 +1,263 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.lang.reflect.Constructor; +import java.time.OffsetDateTime; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import org.apache.commons.lang3.ArrayUtils; + +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; + +final class PojoBuilder implements PropertiesBuilder { + private static final Map, Object> PRIMITIVE_DEFAULTS; + + static { + PRIMITIVE_DEFAULTS = Map.of( + boolean.class, false, + short.class, (short) 0, + int.class, 0, + long.class, 0L, + float.class, 0f, + double.class, 0d); + } + + private final PojoDescriptor descriptor; + private final Constructor ctor; + private final Map ctorArgs; + + static record Arg(Class type, Object value) { + /** + * Create a new Arg, replacing a null value with + * default if the type is a known primitive class. + */ + static Arg withPrimitiveDefault(Class type, Object value) { + if (PRIMITIVE_DEFAULTS.containsKey(type)) { + return new Arg(type, PRIMITIVE_DEFAULTS.get(type)); + } + return new Arg(type, value); + } + + Arg withValue(Object value) { + return new Arg(this.type, value); + } + } + + PojoBuilder(PojoDescriptor descriptor) { + this.descriptor = descriptor; + + var args = descriptor._class().getRecordComponents(); + ctorArgs = new LinkedHashMap(args.length); + + var componentTypes = Arrays.stream(args) + .map(arg -> { + // LinkedHashMap allows null values. + var type = arg.getType(); + ctorArgs.put(arg.getName(), Arg.withPrimitiveDefault(type, null)); + return type; + }) + .toArray(Class[]::new); + try { + ctor = descriptor._class().getDeclaredConstructor(componentTypes); + } catch (NoSuchMethodException | SecurityException e) { + throw new RuntimeException(e); + } + } + + private void setValue(String propertyName, Object value) { + var fieldName = descriptor.fieldName(propertyName); + if (!ctorArgs.containsKey(fieldName)) { + return; + } + var arg = ctorArgs.get(fieldName); + ctorArgs.put(fieldName, arg.withValue(value)); + } + + private Class getArgType(String propertyName) { + return ctorArgs.get(descriptor.fieldName(propertyName)).type(); + } + + private boolean isArray(String propertyName, Class... classes) { + var type = getArgType(propertyName); + if (!type.isArray()) { + return false; + } + if (classes.length == 0) { + return true; + } + var componentType = type.getComponentType(); + for (final var cls : classes) { + if (componentType == cls) { + return true; + } + } + return false; + } + + /** Is either of types. */ + private boolean isType(String propertyName, Class... classes) { + var type = getArgType(propertyName); + for (final var cls : classes) { + if (type == cls) { + return true; + } + } + return false; + } + + @Override + public void setNull(String propertyName) { + setValue(propertyName, null); + } + + @Override + public void setText(String propertyName, String value) { + setValue(propertyName, value); + } + + @Override + public void setBoolean(String propertyName, Boolean value) { + if (isType(propertyName, boolean.class)) { + setValue(propertyName, value.booleanValue()); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setLong(String propertyName, Long value) { + if (isType(propertyName, short.class, Short.class)) { + setValue(propertyName, value.shortValue()); + } else if (isType(propertyName, int.class, Integer.class)) { + setValue(propertyName, value.intValue()); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setDouble(String propertyName, Double value) { + if (isType(propertyName, float.class, Float.class)) { + setValue(propertyName, value.floatValue()); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setBlob(String propertyName, String value) { + setValue(propertyName, value); + } + + @Override + public void setOffsetDateTime(String propertyName, OffsetDateTime value) { + setValue(propertyName, value); + } + + @Override + public void setUuid(String propertyName, UUID value) { + setValue(propertyName, value); + } + + @Override + public void setTextArray(String propertyName, List value) { + setValue(propertyName, isArray(propertyName) + ? value.toArray(String[]::new) + : value); + + } + + @Override + public void setLongArray(String propertyName, List value) { + if (isArray(propertyName, short.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Long::shortValue).toArray(Short[]::new))); + } else if (isArray(propertyName, Short.class)) { + setValue(propertyName, value.stream().map(Long::shortValue).toArray(Short[]::new)); + } else if (isArray(propertyName, int.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Long::intValue).toArray(Integer[]::new))); + } else if (isArray(propertyName, Integer.class)) { + setValue(propertyName, value.stream().map(Long::intValue).toArray(Integer[]::new)); + } else if (isArray(propertyName, long.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Long::longValue).toArray(Long[]::new))); + } else if (isArray(propertyName, Long.class)) { + setValue(propertyName, value.stream().toArray(Long[]::new)); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setDoubleArray(String propertyName, List value) { + if (isArray(propertyName, float.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Double::floatValue).toArray(Float[]::new))); + } else if (isArray(propertyName, Float.class)) { + setValue(propertyName, value.stream().map(Double::floatValue).toArray(Float[]::new)); + } else if (isArray(propertyName, double.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Double::doubleValue).toArray(Double[]::new))); + } else if (isArray(propertyName, Double.class)) { + setValue(propertyName, value.stream().toArray(Double[]::new)); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setUuidArray(String propertyName, List value) { + setValue(propertyName, isArray(propertyName) + ? value.toArray(UUID[]::new) + : value); + } + + @Override + public void setBooleanArray(String propertyName, List value) { + if (isArray(propertyName, boolean.class)) { + setValue(propertyName, ArrayUtils.toPrimitive(value.stream().map(Boolean::booleanValue).toArray(Boolean[]::new))); + } else if (isArray(propertyName, Boolean.class)) { + setValue(propertyName, value.stream().map(Boolean::booleanValue).toArray(Boolean[]::new)); + } else { + setValue(propertyName, value); + } + } + + @Override + public void setOffsetDateTimeArray(String propertyName, List value) { + setValue(propertyName, isArray(propertyName) + ? value.toArray(OffsetDateTime[]::new) + : value); + } + + @Override + public void setNestedObject(String propertyName, Object value) { + throw new UnsupportedOperationException("Unimplemented method 'setNestedObjectArray'"); + } + + @Override + public void setNestedObjectArray(String property, List value) { + throw new UnsupportedOperationException("Unimplemented method 'setNestedObjectArray'"); + } + + @Override + public void setPhoneNumber(String propertyName, PhoneNumber value) { + setValue(propertyName, value); + } + + @Override + public void setGeoCoordinates(String propertyName, GeoCoordinates value) { + setValue(propertyName, value); + } + + @Override + public PropertiesT build() { + Object[] args = ctorArgs.values().stream().map(Arg::value).toArray(); + try { + ctor.setAccessible(true); + return ctor.newInstance(args); + } catch (Exception e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PojoDescriptor.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoDescriptor.java new file mode 100644 index 000000000..4dbf64a89 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoDescriptor.java @@ -0,0 +1,166 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.lang.reflect.Array; +import java.lang.reflect.Field; +import java.lang.reflect.ParameterizedType; +import java.time.OffsetDateTime; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.function.Function; +import java.util.stream.Collectors; + +import com.google.gson.reflect.TypeToken; + +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.annotations.Collection; +import io.weaviate.client6.v1.internal.ObjectBuilder; + +final class PojoDescriptor implements CollectionDescriptor { + private static final Map, Function> CTORS; + + static { + Map, Function> ctors = new HashMap<>() { + { + put(String.class, Property::text); + put(String[].class, Property::textArray); + + put(OffsetDateTime.class, Property::date); + put(OffsetDateTime[].class, Property::dateArray); + + put(UUID.class, Property::uuid); + put(UUID[].class, Property::uuidArray); + + put(boolean.class, Property::bool); + put(Boolean.class, Property::bool); + put(boolean[].class, Property::boolArray); + put(Boolean[].class, Property::boolArray); + + put(short.class, Property::integer); + put(Short.class, Property::integer); + put(int.class, Property::integer); + put(Integer.class, Property::integer); + put(long.class, Property::integer); + put(Long.class, Property::integer); + + put(short[].class, Property::integerArray); + put(Short[].class, Property::integerArray); + put(int[].class, Property::integerArray); + put(Integer[].class, Property::integerArray); + put(long[].class, Property::integerArray); + put(Long[].class, Property::integerArray); + + put(float.class, Property::number); + put(Float.class, Property::number); + put(double.class, Property::number); + put(Double.class, Property::number); + + put(float[].class, Property::numberArray); + put(Float[].class, Property::numberArray); + put(double[].class, Property::numberArray); + put(Double[].class, Property::numberArray); + + put(Map.class, Property::object); + + put(PhoneNumber.class, Property::phoneNumber); + put(GeoCoordinates.class, Property::geoCoordinates); + } + }; + CTORS = Collections.unmodifiableMap(ctors); + } + + private final Class cls; + private final Map propertyToField; + + PojoDescriptor(Class cls) { + this.cls = cls; + this.propertyToField = Arrays.stream(cls.getDeclaredFields()) + .collect(Collectors.toUnmodifiableMap(PojoDescriptor::propertyName, Field::getName)); + } + + Class _class() { + return cls; + } + + /** Get collection property name for a class field. */ + static String propertyName(Field field) { + var annotation = field.getAnnotation(io.weaviate.client6.v1.api.collections.annotations.Property.class); + var propertyName = field.getName(); + if (annotation != null) { + propertyName = annotation.value(); + } + return propertyName; + } + + /** Get class field name for a collection property. */ + String fieldName(String propertyName) { + return propertyToField.getOrDefault(propertyName, propertyName); + } + + @Override + public String collectionName() { + var annotation = cls.getAnnotation(Collection.class); + if (annotation != null) { + return annotation.value(); + } + return cls.getSimpleName(); + } + + @Override + public TypeToken typeToken() { + return TypeToken.get(cls); + } + + @Override + public PropertiesReader propertiesReader(T properties) { + return new PojoReader<>(properties); + } + + @Override + public PropertiesBuilder propertiesBuilder() { + return new PojoBuilder<>(this); + } + + @Override + public Function> configFn() { + return this::inspectClass; + } + + private ObjectBuilder inspectClass(CollectionConfig.Builder b) { + var annotation = cls.getAnnotation(Collection.class); + if (annotation != null) { + b.description(annotation.description()); + } + + // Add properties + for (var field : cls.getDeclaredFields()) { + var propertyName = propertyName(field); + Function ctor; + var type = field.getType(); + + if (type == List.class) { + var ptype = (ParameterizedType) field.getGenericType(); + var argtype = (Class) ptype.getActualTypeArguments()[0]; + var arr = Array.newInstance(argtype, 0).getClass(); + ctor = CTORS.get(arr); + } else { + ctor = CTORS.get(type); + } + + if (ctor == null) { + throw new IllegalArgumentException(type.getCanonicalName() + " property is not supported"); + } + + assert ctor != null; + b.properties(ctor.apply(propertyName)); + } + return b; + } + +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PojoReader.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoReader.java new file mode 100644 index 000000000..41ace15d0 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PojoReader.java @@ -0,0 +1,30 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.util.HashMap; +import java.util.Map; + +final class PojoReader implements PropertiesReader { + private final PropertiesT properties; + + PojoReader(PropertiesT properties) { + this.properties = properties; + } + + @Override + public Map readProperties() { + var out = new HashMap(); + for (var field : properties.getClass().getDeclaredFields()) { + var propertyName = PojoDescriptor.propertyName(field); + if (field.trySetAccessible()) { + try { + out.put(propertyName, field.get(properties)); + } catch (IllegalAccessException e) { + new RuntimeException("accessible flag set but access denied", e); + } + } + // TODO: how do we handle the case where a property is not accessible? + // E.g. we weren't able to set `accessible` flag. + } + return out; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesBuilder.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesBuilder.java new file mode 100644 index 000000000..7f5236485 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesBuilder.java @@ -0,0 +1,48 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.time.OffsetDateTime; +import java.util.List; +import java.util.UUID; + +import io.weaviate.client6.v1.api.collections.GeoCoordinates; +import io.weaviate.client6.v1.api.collections.PhoneNumber; + +public interface PropertiesBuilder { + void setNull(String property); + + void setText(String property, String value); + + void setBoolean(String property, Boolean value); + + void setLong(String property, Long value); + + void setDouble(String property, Double value); + + void setBlob(String property, String value); + + void setOffsetDateTime(String property, OffsetDateTime value); + + void setUuid(String property, UUID value); + + void setTextArray(String property, List value); + + void setLongArray(String property, List value); + + void setDoubleArray(String property, List value); + + void setUuidArray(String property, List value); + + void setBooleanArray(String property, List value); + + void setOffsetDateTimeArray(String property, List value); + + void setNestedObject(String property, Object value); + + void setNestedObjectArray(String property, List value); + + void setPhoneNumber(String property, PhoneNumber value); + + void setGeoCoordinates(String property, GeoCoordinates value); + + T build(); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesReader.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesReader.java new file mode 100644 index 000000000..806b5bd2a --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertiesReader.java @@ -0,0 +1,7 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.util.Map; + +public interface PropertiesReader { + Map readProperties(); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/orm/PropertyFieldNamingStrategy.java b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertyFieldNamingStrategy.java new file mode 100644 index 000000000..0d6bdd80e --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/orm/PropertyFieldNamingStrategy.java @@ -0,0 +1,14 @@ +package io.weaviate.client6.v1.internal.orm; + +import java.lang.reflect.Field; + +import com.google.gson.FieldNamingStrategy; + +public enum PropertyFieldNamingStrategy implements FieldNamingStrategy { + INSTANCE; + + @Override + public String translateName(Field field) { + return PojoDescriptor.propertyName(field); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/AuthenticationInterceptor.java b/src/main/java/io/weaviate/client6/v1/internal/rest/AuthenticationInterceptor.java new file mode 100644 index 000000000..f4a61a7ea --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/AuthenticationInterceptor.java @@ -0,0 +1,83 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.io.IOException; + +import org.apache.hc.client5.http.async.AsyncExecCallback; +import org.apache.hc.client5.http.async.AsyncExecChain; +import org.apache.hc.client5.http.async.AsyncExecChain.Scope; +import org.apache.hc.client5.http.async.AsyncExecChainHandler; +import org.apache.hc.core5.http.EntityDetails; +import org.apache.hc.core5.http.HttpException; +import org.apache.hc.core5.http.HttpRequest; +import org.apache.hc.core5.http.HttpRequestInterceptor; +import org.apache.hc.core5.http.message.BasicHeader; +import org.apache.hc.core5.http.nio.AsyncEntityProducer; +import org.apache.hc.core5.http.protocol.HttpContext; + +import io.weaviate.client6.v1.internal.AsyncTokenProvider; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.TokenProvider.Token; + +/** + * AuthenticationInterceptor can supply Authorization headers to both + * synchronous and asynchronous Apache HttpClient. + */ +class AuthenticationInterceptor implements HttpRequestInterceptor, AsyncExecChainHandler, AutoCloseable { + private static final String AUTHORIZATION = "Authorization"; + + private final TokenProvider tokenProvider; + private final AsyncTokenProvider tokenProviderAsync; + + AuthenticationInterceptor(TokenProvider tokenProvider) { + this.tokenProvider = tokenProvider; + this.tokenProviderAsync = AsyncTokenProvider.wrap(tokenProvider); + } + + /** + * Add Authorization header to a blocking request. + * See {@link HttpRequestInterceptor}. + */ + @Override + public void process(HttpRequest request, EntityDetails entity, HttpContext context) + throws HttpException, IOException { + var token = tokenProvider.getToken(); + setAuthorization(request, token); + } + + /** + * Add Authorization header to a non-blocking request. + * See {@link AsyncExecChainHandler}. + */ + @Override + public void execute(HttpRequest request, AsyncEntityProducer entityProducer, Scope scope, AsyncExecChain chain, + AsyncExecCallback callback) throws HttpException, IOException { + + // CloseableHttpClient is backed by an internal I/O reactor, which runs its own + // threads for non-blocking I/O. It does not expose that executor, so we must + // schedule CompletableFutures on the default AsyncTokenProvider's executor. + tokenProviderAsync.getToken().whenComplete((tok, error) -> { + if (error != null) { + callback.failed(error instanceof Exception ex ? ex : new RuntimeException(error)); + return; + } + + setAuthorization(request, tok); + + try { + chain.proceed(request, entityProducer, scope, callback); + } catch (HttpException | IOException e) { + callback.failed(e); + } + }); + } + + private void setAuthorization(HttpRequest request, Token token) { + request.addHeader(new BasicHeader(AUTHORIZATION, "Bearer " + token.accessToken())); + } + + @Override + public void close() throws Exception { + tokenProvider.close(); + tokenProviderAsync.close(); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java new file mode 100644 index 000000000..64b85a0e6 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java @@ -0,0 +1,37 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Map; +import java.util.function.Function; + +public class BooleanEndpoint extends EndpointBase { + + public static BooleanEndpoint noBody( + Function method, + Function requestUrl, + Function> queryParameters) { + return new BooleanEndpoint<>(method, requestUrl, queryParameters, nullBody()); + } + + public BooleanEndpoint( + Function method, + Function requestUrl, + Function> queryParameters, + Function body) { + super(method, requestUrl, queryParameters, body); + } + + @SuppressWarnings("unchecked") + public BooleanEndpoint allowStatus(Integer... statusCodes) { + super._allowStatusCodes(statusCodes); + return (BooleanEndpoint) this; + } + + @Override + public boolean isError(int statusCode) { + return statusCode != 404 && super.isError(statusCode); + } + + public boolean getResult(int statusCode) { + return statusCode < 400; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java b/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java new file mode 100644 index 000000000..a77d9da29 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java @@ -0,0 +1,207 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.io.IOException; +import java.security.KeyManagementException; +import java.security.NoSuchAlgorithmException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; + +import javax.net.ssl.SSLContext; + +import org.apache.hc.client5.http.async.methods.SimpleHttpRequest; +import org.apache.hc.client5.http.async.methods.SimpleHttpResponse; +import org.apache.hc.client5.http.config.RequestConfig; +import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient; +import org.apache.hc.client5.http.impl.async.HttpAsyncClients; +import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; +import org.apache.hc.client5.http.impl.classic.HttpClients; +import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager; +import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder; +import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManager; +import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManagerBuilder; +import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy; +import org.apache.hc.core5.concurrent.FutureCallback; +import org.apache.hc.core5.http.ClassicHttpRequest; +import org.apache.hc.core5.http.ClassicHttpResponse; +import org.apache.hc.core5.http.ContentType; +import org.apache.hc.core5.http.ParseException; +import org.apache.hc.core5.http.io.entity.EntityUtils; +import org.apache.hc.core5.http.io.support.ClassicRequestBuilder; +import org.apache.hc.core5.io.CloseMode; + +import io.weaviate.client6.v1.api.WeaviateApiException; +import io.weaviate.client6.v1.api.WeaviateTransportException; + +public class DefaultRestTransport implements RestTransport { + private final CloseableHttpClient httpClient; + private final CloseableHttpAsyncClient httpClientAsync; + private final RestTransportOptions transportOptions; + + private AuthenticationInterceptor authInterceptor; + + public DefaultRestTransport(RestTransportOptions transportOptions) { + this.transportOptions = transportOptions; + + // TODO: doesn't make sense to spin up both? + var httpClient = HttpClients.custom() + .setDefaultHeaders(transportOptions.headers()); + var httpClientAsync = HttpAsyncClients.custom() + .setDefaultHeaders(transportOptions.headers()); + + // Apply custom SSL context + if (transportOptions.trustManagerFactory() != null) { + DefaultClientTlsStrategy tlsStrategy; + try { + var sslCtx = SSLContext.getInstance("TLS"); + sslCtx.init(null, transportOptions.trustManagerFactory().getTrustManagers(), null); + tlsStrategy = new DefaultClientTlsStrategy(sslCtx); + } catch (NoSuchAlgorithmException | KeyManagementException e) { + throw new WeaviateTransportException("init custom SSL context", e); + } + + PoolingHttpClientConnectionManager syncManager = PoolingHttpClientConnectionManagerBuilder.create() + .setTlsSocketStrategy(tlsStrategy).build(); + PoolingAsyncClientConnectionManager asyncManager = PoolingAsyncClientConnectionManagerBuilder.create() + .setTlsStrategy(tlsStrategy).build(); + + httpClient.setConnectionManager(syncManager); + httpClientAsync.setConnectionManager(asyncManager); + } + + if (transportOptions.timeout() != null) { + var config = RequestConfig.custom() + .setResponseTimeout(transportOptions.timeout().querySeconds(), TimeUnit.SECONDS) + .build(); + httpClient.setDefaultRequestConfig(config); + httpClientAsync.setDefaultRequestConfig(config); + } + + if (transportOptions.tokenProvider() != null) { + this.authInterceptor = new AuthenticationInterceptor(transportOptions.tokenProvider()); + httpClient.addRequestInterceptorFirst(authInterceptor); + httpClientAsync.addExecInterceptorFirst("auth", authInterceptor); + } + + this.httpClient = httpClient.build(); + this.httpClientAsync = httpClientAsync.build(); + this.httpClientAsync.start(); + } + + private String uri(Endpoint ep, RequestT req) { + return ep.requestUrl(transportOptions, req) + + UrlEncoder.encodeQuery(ep.queryParameters(req)); + } + + @Override + public ResponseT performRequest(RequestT request, + Endpoint endpoint) + throws IOException { + + var req = prepareClassicRequest(request, endpoint); + return this.httpClient.execute(req, r -> this.handleResponse(endpoint, req.getMethod(), req.getRequestUri(), r)); + } + + private ClassicHttpRequest prepareClassicRequest(RequestT request, + Endpoint endpoint) { + var method = endpoint.method(request); + var uri = uri(endpoint, request); + + var req = ClassicRequestBuilder.create(method).setUri(uri); + var body = endpoint.body(request); + if (body != null) { + req.setEntity(body, ContentType.APPLICATION_JSON); + } + if (true) { + } + return req.build(); + } + + private ResponseT handleResponse(Endpoint endpoint, String method, String url, + ClassicHttpResponse httpResponse) throws IOException, ParseException { + var statusCode = httpResponse.getCode(); + var body = httpResponse.getEntity() != null + ? EntityUtils.toString(httpResponse.getEntity()) + : ""; + + return _handleResponse(endpoint, method, url, statusCode, body); + } + + @Override + public CompletableFuture performRequestAsync(RequestT request, + Endpoint endpoint) { + var req = prepareSimpleRequest(request, endpoint); + + var completable = new CompletableFuture(); + this.httpClientAsync.execute(req, new FutureCallback<>() { + + @Override + public void completed(SimpleHttpResponse result) { + completable.complete(result); + } + + @Override + public void failed(Exception ex) { + completable.completeExceptionally(ex); + } + + @Override + public void cancelled() { + completable.cancel(false); + } + + }); + return completable + .thenApply(r -> (ResponseT) handleResponseAsync(endpoint, + req.getMethod(), req.getRequestUri(), r)); + } + + private SimpleHttpRequest prepareSimpleRequest(RequestT request, + Endpoint endpoint) { + var method = endpoint.method(request); + var uri = uri(endpoint, request); + + var body = endpoint.body(request); + var req = SimpleHttpRequest.create(method, uri); + if (body != null) { + req.setBody(body.getBytes(), ContentType.APPLICATION_JSON); + } + return req; + } + + private ResponseT handleResponseAsync( + Endpoint endpoint, + String method, String url, + SimpleHttpResponse httpResponse) { + var statusCode = httpResponse.getCode(); + var body = httpResponse.getBody() != null + ? httpResponse.getBody().getBodyText() + : ""; + return _handleResponse(endpoint, method, url, statusCode, body); + } + + @SuppressWarnings("unchecked") + private ResponseT _handleResponse(Endpoint endpoint, String method, String url, + int statusCode, String body) { + + if (endpoint.isError(statusCode)) { + var message = endpoint.deserializeError(statusCode, body); + throw WeaviateApiException.http(method, url, statusCode, message); + } + if (endpoint instanceof JsonEndpoint json) { + return (ResponseT) json.deserializeResponse(statusCode, body); + } else if (endpoint instanceof BooleanEndpoint bool) { + return (ResponseT) ((Boolean) bool.getResult(statusCode)); + } + + throw new WeaviateTransportException("Unhandled endpoint type " + endpoint.getClass().getSimpleName()); + } + + @Override + public void close() throws Exception { + httpClient.close(); + httpClientAsync.close(CloseMode.GRACEFUL); + if (authInterceptor != null) { + authInterceptor.close(); + } + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java new file mode 100644 index 000000000..a3af57b88 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java @@ -0,0 +1,23 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Map; + +public interface Endpoint { + + String method(RequestT request); + + String requestUrl(RequestT request); + + default String requestUrl(RestTransportOptions transportOptions, RequestT request) { + return transportOptions.baseUrl() + requestUrl(request); + } + + String body(RequestT request); + + Map queryParameters(RequestT request); + + /** Should this status code be considered an error? */ + boolean isError(int statusCode); + + String deserializeError(int statusCode, String responseBody); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java b/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java new file mode 100644 index 000000000..de57747b9 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java @@ -0,0 +1,94 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; + +import com.google.gson.annotations.SerializedName; + +import io.weaviate.client6.v1.internal.json.JSON; + +public abstract class EndpointBase implements Endpoint { + private static final Function NULL_BODY = __ -> null; + + protected final Function method; + protected final Function requestUrl; + protected final Function body; + protected final Function> queryParameters; + + private final Set acceptStatusCodes = new HashSet<>(); + + @SuppressWarnings("unchecked") + protected static Function nullBody() { + return (Function) NULL_BODY; + } + + public EndpointBase( + Function method, + Function requestUrl, + Function> queryParameters, + Function body) { + this.method = method; + this.requestUrl = requestUrl; + this.body = body; + this.queryParameters = queryParameters; + } + + @Override + public String method(RequestT request) { + return method.apply(request); + } + + @Override + public String requestUrl(RequestT request) { + return requestUrl.apply(request); + } + + @Override + public Map queryParameters(RequestT request) { + return queryParameters.apply(request); + } + + @Override + public String body(RequestT request) { + return body.apply(request); + } + + @Override + public boolean isError(int statusCode) { + return statusCode >= 400 && !acceptStatusCodes.contains(statusCode); + } + + protected void _allowStatusCodes(Integer... statusCodes) { + acceptStatusCodes.addAll(Arrays.asList(statusCodes)); + } + + @Override + public String deserializeError(int statusCode, String responseBody) { + if (responseBody.isBlank()) { + return responseBody; + } + { + var response = JSON.deserialize(responseBody, ErrorResponse1.class); + if (response.errors != null && !response.errors.isEmpty()) { + return response.errors.get(0).message(); + } + } + var response = JSON.deserialize(responseBody, ErrorResponse2.class); + if (response.error != null && !response.error.isBlank()) { + return response.error; + } + return responseBody; + } + + private static record ErrorResponse1(@SerializedName("error") List errors) { + private static record ErrorMessage(@SerializedName("message") String message) { + } + } + + private static record ErrorResponse2(@SerializedName("message") String error) { + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/ExternalEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/ExternalEndpoint.java new file mode 100644 index 000000000..0331fdd53 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/ExternalEndpoint.java @@ -0,0 +1,23 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Map; +import java.util.function.BiFunction; +import java.util.function.Function; + +public class ExternalEndpoint extends SimpleEndpoint { + + public ExternalEndpoint( + Function method, + Function requestUrl, + Function> queryParameters, + Function body, + BiFunction deserializeResponse) { + super(method, requestUrl, queryParameters, body, deserializeResponse); + } + + /** Returns {@code requestUrl} without {@code baseUrl} prefix. */ + @Override + public String requestUrl(RestTransportOptions __, RequestT request) { + return requestUrl(request); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/JsonEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/JsonEndpoint.java new file mode 100644 index 000000000..9e04896c4 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/JsonEndpoint.java @@ -0,0 +1,7 @@ +package io.weaviate.client6.v1.internal.rest; + +/** An Endpoint which expects a JSON response body. */ +public interface JsonEndpoint + extends Endpoint { + ResponseT deserializeResponse(int statusCode, String responseBody); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java new file mode 100644 index 000000000..2c960236f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java @@ -0,0 +1,46 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Map; +import java.util.Optional; +import java.util.function.BiFunction; +import java.util.function.Function; + +public class OptionalEndpoint extends SimpleEndpoint> { + + public static OptionalEndpoint noBodyOptional( + Function method, + Function requestUrl, + Function> queryParameters, + BiFunction deserializeResponse) { + return new OptionalEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeResponse); + } + + public static OptionalEndpoint noBodyOptional( + Function method, + Function requestUrl, + Function> queryParameters, + Class cls) { + return new OptionalEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeClass(cls)); + } + + public OptionalEndpoint( + Function method, + Function requestUrl, + Function> queryParameters, + Function body, + BiFunction deserializeResponse) { + super(method, requestUrl, queryParameters, body, optional(deserializeResponse)); + } + + private static BiFunction> optional( + BiFunction deserializeResponse) { + return (statusCode, responseBody) -> statusCode == 404 + ? Optional.empty() + : Optional.ofNullable(deserializeResponse.apply(statusCode, responseBody)); + } + + @Override + public boolean isError(int statusCode) { + return statusCode != 404 && super.isError(statusCode); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransport.java b/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransport.java new file mode 100644 index 000000000..da26c9f12 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransport.java @@ -0,0 +1,13 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.io.IOException; +import java.util.concurrent.CompletableFuture; + +public interface RestTransport extends AutoCloseable { + ResponseT performRequest(RequestT request, + Endpoint endpoint) + throws IOException; + + CompletableFuture performRequestAsync(RequestT request, + Endpoint endpoint); +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransportOptions.java b/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransportOptions.java new file mode 100644 index 000000000..5da4cdd5f --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/RestTransportOptions.java @@ -0,0 +1,43 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Map; + +import javax.net.ssl.TrustManagerFactory; + +import org.apache.hc.core5.http.message.BasicHeader; + +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.TokenProvider; +import io.weaviate.client6.v1.internal.TransportOptions; + +public final class RestTransportOptions extends TransportOptions> { + private static final String API_VERSION = "v1"; + + public RestTransportOptions(String scheme, String host, int port, Map headers, + TokenProvider tokenProvider, TrustManagerFactory trust, Timeout timeout) { + super(scheme, host, port, buildHeaders(headers), tokenProvider, trust, timeout); + } + + private RestTransportOptions(String scheme, String host, int port, Collection headers, + TokenProvider tokenProvider, TrustManagerFactory trust, Timeout timeout) { + super(scheme, host, port, headers, tokenProvider, trust, timeout); + } + + public final RestTransportOptions withTimeout(Timeout timeout) { + return new RestTransportOptions(scheme, host, port, headers, tokenProvider, trustManagerFactory, timeout); + } + + private static final Collection buildHeaders(Map headers) { + var basicHeaders = new HashSet(); + for (var header : headers.entrySet()) { + basicHeaders.add(new BasicHeader(header.getKey(), header.getValue())); + } + return basicHeaders; + } + + public String baseUrl() { + return scheme() + "://" + host() + ":" + port() + "/" + API_VERSION; + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java new file mode 100644 index 000000000..b65dc6130 --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java @@ -0,0 +1,74 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.util.Map; +import java.util.function.BiFunction; +import java.util.function.Function; + +import io.weaviate.client6.v1.internal.json.JSON; + +public class SimpleEndpoint extends EndpointBase + implements JsonEndpoint { + private static final BiFunction NULL_RESPONSE = (__code, __body) -> null; + + private final BiFunction deserializeResponse; + + protected static BiFunction nullResponse() { + return NULL_RESPONSE; + } + + protected static BiFunction deserializeClass(Class cls) { + return (statusCode, response) -> JSON.deserialize(response, cls); + } + + public static SimpleEndpoint noBody( + Function method, + Function requestUrl, + Function> queryParameters, + BiFunction deserializeResponse) { + return new SimpleEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeResponse); + } + + public static SimpleEndpoint noBody( + Function method, + Function requestUrl, + Function> queryParameters, + Class cls) { + return new SimpleEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeClass(cls)); + } + + public static SimpleEndpoint sideEffect( + Function method, + Function requestUrl, + Function> queryParameters, + Function body) { + return new SimpleEndpoint<>(method, requestUrl, queryParameters, body, nullResponse()); + } + + public static SimpleEndpoint sideEffect( + Function method, + Function requestUrl, + Function> queryParameters) { + return new SimpleEndpoint<>(method, requestUrl, queryParameters, nullBody(), nullResponse()); + } + + public SimpleEndpoint( + Function method, + Function requestUrl, + Function> queryParameters, + Function body, + BiFunction deserializeResponse) { + super(method, requestUrl, queryParameters, body); + this.deserializeResponse = deserializeResponse; + } + + @SuppressWarnings("unchecked") + public SimpleEndpoint allowStatus(Integer... statusCodes) { + super._allowStatusCodes(statusCodes); + return (SimpleEndpoint) this; + } + + @Override + public ResponseT deserializeResponse(int statusCode, String responseBody) { + return deserializeResponse.apply(statusCode, responseBody); + } +} diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java b/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java new file mode 100644 index 000000000..0d5b152ba --- /dev/null +++ b/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java @@ -0,0 +1,49 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.io.UnsupportedEncodingException; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.util.Map; +import java.util.stream.Collectors; + +public final class UrlEncoder { + + public static String encodeValue(Object value) { + try { + return URLEncoder.encode(value.toString(), StandardCharsets.UTF_8.toString()); + } catch (UnsupportedEncodingException e) { + throw new AssertionError(e); // should never happen with a standard encoding + } + } + + /** + * Encodes each key-value pair into a URL-compatible query string, omitting any + * {@code null} or blank (in case of String parameter) values. + * Each value is represented by the return of its [@conde toString()} method. + * + * @return URL query string or empty string if the map was empty + * or contained no valid parameters. + */ + public static String encodeQuery(Map queryParams) { + if (queryParams == null || queryParams.isEmpty()) { + return ""; + } + var query = queryParams.entrySet().stream() + .filter(qp -> { + if (qp == null || qp.getValue() == null) { + return false; + } + if (qp.getValue() == null) { + return false; + } else if (qp.getValue() instanceof String str) { + return !str.isBlank(); + } + return true; + }) + .filter(qp -> qp.getKey() != null && qp.getValue() != null) + .map(qp -> qp.getKey() + "=" + encodeValue(qp.getValue())) + .collect(Collectors.joining("&", "?", "")); + + return query.equals("?") ? "" : query; + } +} diff --git a/src/main/proto/v0/batch.proto b/src/main/proto/v0/batch.proto deleted file mode 100644 index 8b57f95e6..000000000 --- a/src/main/proto/v0/batch.proto +++ /dev/null @@ -1,12 +0,0 @@ -syntax = "proto3"; - -package weaviategrpc; - -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v0"; -option java_outer_classname = "WeaviateProtoBatch"; - -message BatchObjectsRequest { -} -message BatchObjectsReply { -} diff --git a/src/main/proto/v0/search_get.proto b/src/main/proto/v0/search_get.proto deleted file mode 100644 index 86b6c1d44..000000000 --- a/src/main/proto/v0/search_get.proto +++ /dev/null @@ -1,12 +0,0 @@ -syntax = "proto3"; - -package weaviategrpc; - -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v0"; -option java_outer_classname = "WeaviateProtoSearchGet"; - -message SearchRequest { -} -message SearchReply { -} diff --git a/src/main/proto/v0/weaviate.proto b/src/main/proto/v0/weaviate.proto deleted file mode 100644 index 8797ccb78..000000000 --- a/src/main/proto/v0/weaviate.proto +++ /dev/null @@ -1,15 +0,0 @@ -syntax = "proto3"; - -package weaviategrpc; - -import "v0/batch.proto"; -import "v0/search_get.proto"; - -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v0"; -option java_outer_classname = "WeaviateProto"; - -service Weaviate { - rpc Search(SearchRequest) returns (SearchReply) {}; - rpc BatchObjects(BatchObjectsRequest) returns (BatchObjectsReply) {}; -} diff --git a/src/main/proto/v1/aggregate.proto b/src/main/proto/v1/aggregate.proto index 499439352..272b78e92 100644 --- a/src/main/proto/v1/aggregate.proto +++ b/src/main/proto/v1/aggregate.proto @@ -5,8 +5,7 @@ package weaviate.v1; import "v1/base.proto"; import "v1/base_search.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoAggregate"; message AggregateRequest { diff --git a/src/main/proto/v1/base.proto b/src/main/proto/v1/base.proto index 85b4ca42b..cf0220793 100644 --- a/src/main/proto/v1/base.proto +++ b/src/main/proto/v1/base.proto @@ -3,8 +3,7 @@ syntax = "proto3"; package weaviate.v1; import "google/protobuf/struct.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoBase"; enum ConsistencyLevel { diff --git a/src/main/proto/v1/base_search.proto b/src/main/proto/v1/base_search.proto index 557320176..f1b241b91 100644 --- a/src/main/proto/v1/base_search.proto +++ b/src/main/proto/v1/base_search.proto @@ -4,8 +4,7 @@ package weaviate.v1; import "v1/base.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoBaseSearch"; enum CombinationMethod { @@ -31,7 +30,8 @@ message Targets { message VectorForTarget { string name = 1; - bytes vector_bytes = 2 [deprecated = true]; // deprecated in 1.29.0 - use vectors + bytes vector_bytes = 2 + [ deprecated = true ]; // deprecated in 1.29.0 - use vectors repeated Vectors vectors = 3; } @@ -49,7 +49,8 @@ message Hybrid { string query = 1; repeated string properties = 2; // protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED - repeated float vector = 3 [deprecated = true]; // will be removed in the future, use vectors + repeated float vector = 3 + [ deprecated = true ]; // will be removed in the future, use vectors float alpha = 4; enum FusionType { FUSION_TYPE_UNSPECIFIED = 0; @@ -57,30 +58,36 @@ message Hybrid { FUSION_TYPE_RELATIVE_SCORE = 2; } FusionType fusion_type = 5; - bytes vector_bytes = 6 [deprecated = true]; // deprecated in 1.29.0 - use vectors - repeated string target_vectors = 7 [deprecated = true]; // deprecated in 1.26 - use targets - NearTextSearch near_text = 8; // targets in msg is ignored and should not be set for hybrid - NearVector near_vector = 9; // same as above. Use the target vector in the hybrid message + bytes vector_bytes = 6 + [ deprecated = true ]; // deprecated in 1.29.0 - use vectors + repeated string target_vectors = 7 + [ deprecated = true ]; // deprecated in 1.26 - use targets + NearTextSearch near_text = + 8; // targets in msg is ignored and should not be set for hybrid + NearVector near_vector = + 9; // same as above. Use the target vector in the hybrid message Targets targets = 10; optional SearchOperatorOptions bm25_search_operator = 11; // only vector distance, but keep it extendable - oneof threshold { - float vector_distance = 20; - }; + oneof threshold { float vector_distance = 20; }; repeated Vectors vectors = 21; } message NearVector { // protolint:disable:next REPEATED_FIELD_NAMES_PLURALIZED - repeated float vector = 1 [deprecated = true]; // will be removed in the future, use vectors + repeated float vector = 1 + [ deprecated = true ]; // will be removed in the future, use vectors optional double certainty = 2; optional double distance = 3; - bytes vector_bytes = 4 [deprecated = true]; // deprecated in 1.29.0 - use vectors - repeated string target_vectors = 5 [deprecated = true]; // deprecated in 1.26 - use targets + bytes vector_bytes = 4 + [ deprecated = true ]; // deprecated in 1.29.0 - use vectors + repeated string target_vectors = 5 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 6; - map vector_per_target = 7 [deprecated = true]; // deprecated in 1.26.2 - use vector_for_targets + map vector_per_target = 7 + [ deprecated = true ]; // deprecated in 1.26.2 - use vector_for_targets repeated VectorForTarget vector_for_targets = 8; repeated Vectors vectors = 9; } @@ -89,7 +96,8 @@ message NearObject { string id = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; } @@ -106,7 +114,8 @@ message NearTextSearch { optional double distance = 3; optional Move move_to = 4; optional Move move_away = 5; - repeated string target_vectors = 6 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 6 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 7; }; @@ -114,7 +123,8 @@ message NearImageSearch { string image = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; }; @@ -122,7 +132,8 @@ message NearAudioSearch { string audio = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; }; @@ -130,7 +141,8 @@ message NearVideoSearch { string video = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; }; @@ -138,7 +150,8 @@ message NearDepthSearch { string depth = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; } @@ -146,7 +159,8 @@ message NearThermalSearch { string thermal = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; } @@ -154,7 +168,8 @@ message NearIMUSearch { string imu = 1; optional double certainty = 2; optional double distance = 3; - repeated string target_vectors = 4 [deprecated = true]; // deprecated in 1.26 - use targets + repeated string target_vectors = 4 + [ deprecated = true ]; // deprecated in 1.26 - use targets Targets targets = 5; } diff --git a/src/main/proto/v1/batch.proto b/src/main/proto/v1/batch.proto index 72204577f..12fdbb994 100644 --- a/src/main/proto/v1/batch.proto +++ b/src/main/proto/v1/batch.proto @@ -5,8 +5,7 @@ package weaviate.v1; import "google/protobuf/struct.proto"; import "v1/base.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoBatch"; message BatchObjectsRequest { diff --git a/src/main/proto/v1/batch_delete.proto b/src/main/proto/v1/batch_delete.proto index d0a9f8e82..4fea818a2 100644 --- a/src/main/proto/v1/batch_delete.proto +++ b/src/main/proto/v1/batch_delete.proto @@ -4,8 +4,7 @@ package weaviate.v1; import "v1/base.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoBatchDelete"; message BatchDeleteRequest { diff --git a/src/main/proto/v1/file_replication.proto b/src/main/proto/v1/file_replication.proto index cf289d4c3..4090eb3ee 100644 --- a/src/main/proto/v1/file_replication.proto +++ b/src/main/proto/v1/file_replication.proto @@ -2,9 +2,8 @@ syntax = "proto3"; package weaviate.v1; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; -option java_outer_classname = "WeaviateProtoReplicate"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; +option java_outer_classname = "WeaviateProtoFileReplication"; enum CompressionType { COMPRESSION_TYPE_UNSPECIFIED = 0; // No compression diff --git a/src/main/proto/v1/generative.proto b/src/main/proto/v1/generative.proto index e2707ec86..fb3deda67 100644 --- a/src/main/proto/v1/generative.proto +++ b/src/main/proto/v1/generative.proto @@ -4,8 +4,7 @@ package weaviate.v1; import "v1/base.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoGenerative"; message GenerativeSearch { @@ -13,9 +12,9 @@ message GenerativeSearch { string prompt = 1; bool debug = 2; // only allow one at the beginning, but multiple in the future - repeated GenerativeProvider queries = 3; + repeated GenerativeProvider queries = 3; } - + message Grouped { string task = 1; optional TextArray properties = 2; @@ -24,9 +23,9 @@ message GenerativeSearch { bool debug = 4; } - string single_response_prompt = 1 [deprecated = true]; - string grouped_response_task = 2 [deprecated = true]; - repeated string grouped_properties = 3 [deprecated = true]; + string single_response_prompt = 1 [ deprecated = true ]; + string grouped_response_task = 2 [ deprecated = true ]; + repeated string grouped_properties = 3 [ deprecated = true ]; Single single = 4; Grouped grouped = 5; } @@ -50,7 +49,7 @@ message GenerativeProvider { } } -message GenerativeAnthropic{ +message GenerativeAnthropic { optional string base_url = 1; optional int64 max_tokens = 2; optional string model = 3; @@ -62,13 +61,13 @@ message GenerativeAnthropic{ optional TextArray image_properties = 9; } -message GenerativeAnyscale{ +message GenerativeAnyscale { optional string base_url = 1; optional string model = 2; optional double temperature = 3; } -message GenerativeAWS{ +message GenerativeAWS { optional string model = 3; optional double temperature = 8; optional string service = 9; @@ -80,7 +79,7 @@ message GenerativeAWS{ optional TextArray image_properties = 15; } -message GenerativeCohere{ +message GenerativeCohere { optional string base_url = 1; optional double frequency_penalty = 2; optional int64 max_tokens = 3; @@ -92,10 +91,9 @@ message GenerativeCohere{ optional double temperature = 9; } -message GenerativeDummy{ -} +message GenerativeDummy {} -message GenerativeMistral{ +message GenerativeMistral { optional string base_url = 1; optional int64 max_tokens = 2; optional string model = 3; @@ -103,7 +101,7 @@ message GenerativeMistral{ optional double top_p = 5; } -message GenerativeOllama{ +message GenerativeOllama { optional string api_endpoint = 1; optional string model = 2; optional double temperature = 3; @@ -111,7 +109,7 @@ message GenerativeOllama{ optional TextArray image_properties = 5; } -message GenerativeOpenAI{ +message GenerativeOpenAI { optional double frequency_penalty = 1; optional int64 max_tokens = 2; optional string model = 3; @@ -129,7 +127,7 @@ message GenerativeOpenAI{ optional TextArray image_properties = 15; } -message GenerativeGoogle{ +message GenerativeGoogle { optional double frequency_penalty = 1; optional int64 max_tokens = 2; optional string model = 3; @@ -146,7 +144,7 @@ message GenerativeGoogle{ optional TextArray image_properties = 14; } -message GenerativeDatabricks{ +message GenerativeDatabricks { optional string endpoint = 1; optional string model = 2; optional double frequency_penalty = 3; @@ -160,7 +158,7 @@ message GenerativeDatabricks{ optional double top_p = 11; } -message GenerativeFriendliAI{ +message GenerativeFriendliAI { optional string base_url = 1; optional string model = 2; optional int64 max_tokens = 3; @@ -169,7 +167,7 @@ message GenerativeFriendliAI{ optional double top_p = 6; } -message GenerativeNvidia{ +message GenerativeNvidia { optional string base_url = 1; optional string model = 2; optional double temperature = 3; @@ -177,7 +175,7 @@ message GenerativeNvidia{ optional int64 max_tokens = 5; } -message GenerativeXAI{ +message GenerativeXAI { optional string base_url = 1; optional string model = 2; optional double temperature = 3; @@ -195,11 +193,9 @@ message GenerativeAnthropicMetadata { Usage usage = 1; } -message GenerativeAnyscaleMetadata { -} +message GenerativeAnyscaleMetadata {} -message GenerativeAWSMetadata { -} +message GenerativeAWSMetadata {} message GenerativeCohereMetadata { message ApiVersion { @@ -223,8 +219,7 @@ message GenerativeCohereMetadata { optional TextArray warnings = 4; } -message GenerativeDummyMetadata { -} +message GenerativeDummyMetadata {} message GenerativeMistralMetadata { message Usage { @@ -235,8 +230,7 @@ message GenerativeMistralMetadata { optional Usage usage = 1; } -message GenerativeOllamaMetadata { -} +message GenerativeOllamaMetadata {} message GenerativeOpenAIMetadata { message Usage { @@ -256,9 +250,7 @@ message GenerativeGoogleMetadata { optional TokenCount input_token_count = 1; optional TokenCount output_token_count = 2; } - message Metadata { - optional TokenMetadata token_metadata = 1; - } + message Metadata { optional TokenMetadata token_metadata = 1; } message UsageMetadata { optional int64 prompt_token_count = 1; optional int64 candidates_token_count = 2; @@ -328,10 +320,6 @@ message GenerativeReply { optional GenerativeMetadata metadata = 3; } -message GenerativeResult { - repeated GenerativeReply values = 1; -} +message GenerativeResult { repeated GenerativeReply values = 1; } -message GenerativeDebug { - optional string full_prompt = 1; -} +message GenerativeDebug { optional string full_prompt = 1; } diff --git a/src/main/proto/v1/properties.proto b/src/main/proto/v1/properties.proto index ed7fa23aa..fa076184e 100644 --- a/src/main/proto/v1/properties.proto +++ b/src/main/proto/v1/properties.proto @@ -4,8 +4,7 @@ package weaviate.v1; import "google/protobuf/struct.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoProperties"; message Properties { @@ -92,4 +91,4 @@ message PhoneNumber { uint64 national = 5; string national_formatted = 6; bool valid = 7; -} \ No newline at end of file +} diff --git a/src/main/proto/v1/search_get.proto b/src/main/proto/v1/search_get.proto index b19968af9..e3ac192b0 100644 --- a/src/main/proto/v1/search_get.proto +++ b/src/main/proto/v1/search_get.proto @@ -7,8 +7,7 @@ import "v1/base_search.proto"; import "v1/generative.proto"; import "v1/properties.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoSearchGet"; message SearchRequest { diff --git a/src/main/proto/v1/tenants.proto b/src/main/proto/v1/tenants.proto index 2d39c6c98..3fa0c4c85 100644 --- a/src/main/proto/v1/tenants.proto +++ b/src/main/proto/v1/tenants.proto @@ -2,8 +2,7 @@ syntax = "proto3"; package weaviate.v1; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProtoTenants"; enum TenantActivityStatus { @@ -11,7 +10,7 @@ enum TenantActivityStatus { TENANT_ACTIVITY_STATUS_HOT = 1; TENANT_ACTIVITY_STATUS_COLD = 2; // Originally TENANT_ACTIVITY_STATUS_WARM = 3; - reserved 3; + reserved 3; TENANT_ACTIVITY_STATUS_FROZEN = 4; TENANT_ACTIVITY_STATUS_UNFREEZING = 5; TENANT_ACTIVITY_STATUS_FREEZING = 6; diff --git a/src/main/proto/v1/weaviate.proto b/src/main/proto/v1/weaviate.proto index 1e074c4a0..f8fd6fbe7 100644 --- a/src/main/proto/v1/weaviate.proto +++ b/src/main/proto/v1/weaviate.proto @@ -8,8 +8,7 @@ import "v1/batch_delete.proto"; import "v1/search_get.proto"; import "v1/tenants.proto"; -option go_package = "github.com/weaviate/weaviate/grpc/generated;protocol"; -option java_package = "io.weaviate.client.grpc.protocol.v1"; +option java_package = "io.weaviate.client6.v1.internal.grpc.protocol"; option java_outer_classname = "WeaviateProto"; service Weaviate { diff --git a/src/test/java/io/weaviate/client/ConfigTest.java b/src/test/java/io/weaviate/client/ConfigTest.java deleted file mode 100644 index 7d2a615cc..000000000 --- a/src/test/java/io/weaviate/client/ConfigTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package io.weaviate.client; - -import java.util.HashMap; -import java.util.Map; -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class ConfigTest extends TestCase { - @Test - public void testConfig() { - // given - String scheme = "https"; - String domain = "localhost:8080"; - // when - Config config = new Config(scheme, domain); - // then - Assert.assertEquals("https://localhost:8080/v1", config.getBaseURL()); - } - - @Test - public void testConfigHeaders() { - // given - String scheme = "https"; - String domain = "localhost:8080"; - Map headers = new HashMap<>(); - headers.put("Authorization", "Bearer valueA"); - headers.put("Authorization", "Bearer valueB"); - // when - Config config = new Config(scheme, domain, headers); - // then - Assert.assertEquals("https://localhost:8080/v1", config.getBaseURL()); - Assert.assertEquals(1, config.getHeaders().size()); - } - - @Test - public void testConfigProxy() { - // given - String scheme = "https"; - String domain = "localhost:8080"; - String proxyHost = "proxy"; - int proxyPort = 8080; - String proxyScheme = "http"; - // when - Config config = new Config(scheme, domain); - config.setProxy(proxyHost, proxyPort, proxyScheme); - // then - Assert.assertEquals("https://localhost:8080/v1", config.getBaseURL()); - Assert.assertEquals("proxy", config.getProxyHost()); - Assert.assertEquals(8080, config.getProxyPort()); - Assert.assertEquals("http", config.getProxyScheme()); - } -} diff --git a/src/test/java/io/weaviate/client/WeaviateAuthClientTest.java b/src/test/java/io/weaviate/client/WeaviateAuthClientTest.java deleted file mode 100644 index a444ddb1f..000000000 --- a/src/test/java/io/weaviate/client/WeaviateAuthClientTest.java +++ /dev/null @@ -1,191 +0,0 @@ -package io.weaviate.client; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -import org.apache.http.client.methods.HttpGet; -import org.junit.AfterClass; -import org.junit.Test; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.HttpRequest; -import org.mockserver.verify.VerificationTimes; - -import io.weaviate.client.v1.auth.exception.AuthException; - -public class WeaviateAuthClientTest { - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8899; - private static final int OIDC_MOCK_SERVER_PORT = 8999; - private static final Config MOCK_SERVER_CONFIG = new Config( - "http", - String.format("%s:%s", MOCK_SERVER_HOST, MOCK_SERVER_PORT)); - private static final String OIDC_PATH = "/v1/.well-known/openid-configuration"; - - private static final ClientAndServer mockServer = startClientAndServer(MOCK_SERVER_PORT); - private static final ClientAndServer oidcMockServer = startClientAndServer(OIDC_MOCK_SERVER_PORT); - - @AfterClass - public static void after() { - mockServer.stop(); - oidcMockServer.stop(); - } - - @Test - public void test404Case() { - // given - String msg = "Auth001: The client was configured to use authentication, but weaviate is configured without authentication. Are you sure this is " - + - "correct?"; - - mockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath(OIDC_PATH)) - .respond( - response().withStatusCode(404)); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .retrieveRecordedRequests( - request().withMethod("GET").withPath(OIDC_PATH)); - // when - AuthException exceptionClientCredentials = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientCredentials(MOCK_SERVER_CONFIG, "some-secret", null)); - AuthException exceptionClientPassword = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientPassword(MOCK_SERVER_CONFIG, "user", "pass", null)); - AuthException exceptionBearerToken = assertThrows(AuthException.class, - () -> WeaviateAuthClient.bearerToken(MOCK_SERVER_CONFIG, "access-token", 0l, "refresh-token")); - // then - assertEquals(msg, exceptionClientCredentials.getMessage()); - assertEquals(msg, exceptionClientPassword.getMessage()); - assertEquals(msg, exceptionBearerToken.getMessage()); - - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .verify( - request() - .withPath(OIDC_PATH), - VerificationTimes.exactly(3)); - } - - @Test - public void test503Case() { - // given - int statusCode = 503; - String msg = String.format("OIDC configuration url %s returned status code %s", - String.format("http://%s:%s%s", MOCK_SERVER_HOST, MOCK_SERVER_PORT, OIDC_PATH), statusCode); - - mockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath(OIDC_PATH)) - .respond( - response().withStatusCode(statusCode)); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .retrieveRecordedRequests( - request().withMethod("GET").withPath(OIDC_PATH)); - // when - AuthException exceptionClientCredentials = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientCredentials(MOCK_SERVER_CONFIG, "some-secret", null)); - AuthException exceptionClientPassword = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientPassword(MOCK_SERVER_CONFIG, "user", "pass", null)); - AuthException exceptionBearerToken = assertThrows(AuthException.class, - () -> WeaviateAuthClient.bearerToken(MOCK_SERVER_CONFIG, "access-token", 0l, "refresh-token")); - // then - assertEquals(msg, exceptionClientCredentials.getMessage()); - assertEquals(msg, exceptionClientPassword.getMessage()); - assertEquals(msg, exceptionBearerToken.getMessage()); - - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .verify( - request() - .withPath(OIDC_PATH), - VerificationTimes.exactly(6)); - } - - @Test - public void test201OIDCHrefCase() { - // given - int statusCode = 201; - String hrefURL = String.format("http://%s:%s/oidc", MOCK_SERVER_HOST, OIDC_MOCK_SERVER_PORT); - String msg = String.format("OIDC configuration url %s returned status code %s", - hrefURL, statusCode); - - mockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath(OIDC_PATH)) - .respond( - response().withStatusCode(200).withBody(String.format("{\"href\":\"%s\"}", hrefURL))); - oidcMockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, OIDC_MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath("/oidc")) - .respond( - response().withStatusCode(statusCode)); - // when - AuthException exceptionClientCredentials = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientCredentials(MOCK_SERVER_CONFIG, "some-secret", null)); - AuthException exceptionClientPassword = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientPassword(MOCK_SERVER_CONFIG, "user", "pass", null)); - AuthException exceptionBearerToken = assertThrows(AuthException.class, - () -> WeaviateAuthClient.bearerToken(MOCK_SERVER_CONFIG, "access-token", 0l, "refresh-token")); - // then - assertEquals(msg, exceptionClientCredentials.getMessage()); - assertEquals(msg, exceptionClientPassword.getMessage()); - assertEquals(msg, exceptionBearerToken.getMessage()); - } - - @Test - public void test200ParseException() throws AuthException { - // given - String hrefURL = String.format("http://%s:%s/oidc", MOCK_SERVER_HOST, OIDC_MOCK_SERVER_PORT); - String msg = "Invalid JSON"; - - mockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath(OIDC_PATH)) - .respond( - response().withStatusCode(200).withBody(String.format("{\"href\":\"%s\"}", hrefURL))); - oidcMockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, OIDC_MOCK_SERVER_PORT) - .when( - request().withMethod("GET").withPath("/oidc")) - .respond( - response().withStatusCode(200).withBody("{parse-exception}")); - // when - AuthException exceptionClientCredentials = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientCredentials(MOCK_SERVER_CONFIG, "some-secret", null)); - AuthException exceptionClientPassword = assertThrows(AuthException.class, - () -> WeaviateAuthClient.clientPassword(MOCK_SERVER_CONFIG, "user", "pass", null)); - WeaviateClient weaviateClient = WeaviateAuthClient.bearerToken(MOCK_SERVER_CONFIG, "access-token", 0l, ""); - // then - assertEquals(msg, exceptionClientCredentials.getMessage()); - assertEquals(msg, exceptionClientPassword.getMessage()); - assertNotNull(weaviateClient); - } - - @Test - public void shouldAddApiKeyHeader() throws AuthException { - String metaPath = "/v1/meta"; - String apiKey = "some-api-key"; - HttpRequest requestDefinition = request().withMethod(HttpGet.METHOD_NAME).withPath(metaPath); - - mockServer.reset(); - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .when(requestDefinition) - .respond(response().withStatusCode(200)); - - WeaviateAuthClient.apiKey(MOCK_SERVER_CONFIG, apiKey).misc().metaGetter().run(); - - new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT) - .verify( - request().withMethod(HttpGet.METHOD_NAME).withPath(metaPath) - .withHeader("Authorization", String.format("Bearer %s", apiKey)), - VerificationTimes.once()); - } -} diff --git a/src/test/java/io/weaviate/client/base/SerializerTest.java b/src/test/java/io/weaviate/client/base/SerializerTest.java deleted file mode 100644 index a7f2dd826..000000000 --- a/src/test/java/io/weaviate/client/base/SerializerTest.java +++ /dev/null @@ -1,73 +0,0 @@ -package io.weaviate.client.base; - -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class SerializerTest extends TestCase { - - @Test - public void testToResponse() { - // given - Serializer s = new Serializer(); - String description = "test äüëö"; - String jsonString = "{\"description\":\""+description+"\"}"; - // when - TestObj deserialized = s.toResponse(jsonString, TestObj.class); - // then - Assert.assertNotNull(deserialized); - Assert.assertEquals(description, deserialized.getDescription()); - } - - @Test - public void testToJsonString() { - // given - Serializer s = new Serializer(); - TestObj obj = new TestObj("test äüëö"); - // when - String serialized = s.toJsonString(obj); - // then - Assert.assertNotNull(serialized); - Assert.assertEquals("{\"description\":\"test äüëö\"}", serialized); - } - - @Test - public void testErrorResponse() { - // given - Serializer s = new Serializer(); - String jsonString = "{\"error\":[{\"message\":\"get extend: unknown capability: featureProjection\"}]}"; - // when - WeaviateErrorResponse deserialized = s.toResponse(jsonString, WeaviateErrorResponse.class); - // then - Assert.assertNotNull(deserialized); - Assert.assertNull(deserialized.getMessage()); - Assert.assertNull(deserialized.getCode()); - Assert.assertNotNull(deserialized.getError()); - Assert.assertNotNull(deserialized.getError().get(0)); - Assert.assertEquals("get extend: unknown capability: featureProjection", deserialized.getError().get(0).getMessage()); - } - - @Test - public void testErrorResponseWithNoError() { - // given - Serializer s = new Serializer(); - String jsonString = "{\"code\":601,\"message\":\"id in body must be of type uuid: \\\"TODO_4\\\"\"}"; - // when - WeaviateErrorResponse deserialized = s.toResponse(jsonString, WeaviateErrorResponse.class); - // then - Assert.assertNotNull(deserialized); - Assert.assertNull(deserialized.getError()); - Assert.assertEquals(new Integer(601), deserialized.getCode()); - Assert.assertEquals("id in body must be of type uuid: \"TODO_4\"", deserialized.getMessage()); - } -} - -class TestObj { - private String description; - public TestObj(String description) { - this.description = description; - } - public String getDescription() { - return description; - } -} diff --git a/src/test/java/io/weaviate/client/base/http/impl/CommonsHttpClientImplTest.java b/src/test/java/io/weaviate/client/base/http/impl/CommonsHttpClientImplTest.java deleted file mode 100644 index 0ede3a577..000000000 --- a/src/test/java/io/weaviate/client/base/http/impl/CommonsHttpClientImplTest.java +++ /dev/null @@ -1,206 +0,0 @@ -package io.weaviate.client.base.http.impl; - -import io.weaviate.client.base.http.HttpResponse; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStreamReader; -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import java.util.stream.Collectors; -import org.apache.hc.client5.http.classic.methods.HttpDelete; -import org.apache.hc.client5.http.classic.methods.HttpGet; -import org.apache.hc.client5.http.classic.methods.HttpHead; -import org.apache.hc.client5.http.classic.methods.HttpPatch; -import org.apache.hc.client5.http.classic.methods.HttpPost; -import org.apache.hc.client5.http.classic.methods.HttpPut; -import org.apache.hc.client5.http.classic.methods.HttpUriRequest; -import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase; -import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; -import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse; -import org.apache.hc.core5.http.HttpHeaders; -import org.apache.hc.core5.http.message.BasicHeader; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import static org.mockito.ArgumentMatchers.any; -import org.mockito.Captor; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; - -@RunWith(MockitoJUnitRunner.class) -public class CommonsHttpClientImplTest { - - private static final String URL = "http://example.weaviate/"; - private static final int STATUS = 200; - private static final String JSON_PAYLOAD = "[123]"; - private static final Map ADDITIONAL_HEADERS = new HashMap() {{ - put("X-Some-Header-1", "SomeValue1"); - put("X-Some-Header-2", "SomeValue2"); - }}; - - @Captor - private ArgumentCaptor captor; - @Mock - private CloseableHttpClient clientMock; - @Mock - private CloseableHttpResponse responseMock; - - @Before - public void before() throws IOException { - Mockito.when(clientMock.execute(any(HttpUriRequest.class))) - .thenReturn(responseMock); - Mockito.when(responseMock.getCode()) - .thenReturn(STATUS); - } - - @Test - public void shouldAddHeadersOnGetRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "*/*"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendGetRequest(URL); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpGet.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEmpty(request); - } - - @Test - public void shouldAddHeadersOnHeadRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "*/*"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendHeadRequest(URL); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpHead.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEmpty(request); - } - - @Test - public void shouldAddHeadersOnPostRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "application/json"); - expectedHeaders.put(HttpHeaders.CONTENT_TYPE, "application/json"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendPostRequest(URL, JSON_PAYLOAD); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpPost.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEqual(request, JSON_PAYLOAD); - } - - @Test - public void shouldAddHeadersOnPatchRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "application/json"); - expectedHeaders.put(HttpHeaders.CONTENT_TYPE, "application/json"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendPatchRequest(URL, JSON_PAYLOAD); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpPatch.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEqual(request, JSON_PAYLOAD); - } - - @Test - public void shouldAddHeadersOnPutRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "application/json"); - expectedHeaders.put(HttpHeaders.CONTENT_TYPE, "application/json"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendPutRequest(URL, JSON_PAYLOAD); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpPut.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEqual(request, JSON_PAYLOAD); - } - - @Test - public void shouldAddHeadersOnDeleteWithBodyRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "application/json"); - expectedHeaders.put(HttpHeaders.CONTENT_TYPE, "application/json"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendDeleteRequest(URL, JSON_PAYLOAD); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpDelete.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEqual(request, JSON_PAYLOAD); - } - - @Test - public void shouldAddHeadersOnDeleteRequest() throws Exception { - Map expectedHeaders = new HashMap<>(ADDITIONAL_HEADERS); - expectedHeaders.put(HttpHeaders.ACCEPT, "*/*"); - - CommonsHttpClientImpl client = new CommonsHttpClientImpl(ADDITIONAL_HEADERS, () -> clientMock); - HttpResponse response = client.sendDeleteRequest(URL, null); - - assertThat(response.getStatusCode()).isEqualTo(STATUS); - Mockito.verify(clientMock).execute(captor.capture()); - HttpUriRequest request = captor.getValue(); - assertThat(request.getMethod()).isEqualTo(HttpDelete.METHOD_NAME); - assertThat(request.getUri()).isEqualByComparingTo(URI.create(URL)); - assertHeadersMatch(request, expectedHeaders); - assertContentEmpty(request); - } - - private void assertHeadersMatch(HttpUriRequest request, Map expectedHeaders) { - Map headers = Arrays.stream(request.getHeaders()) - .map(BasicHeader.class::cast) - .collect(Collectors.toMap(BasicHeader::getName, BasicHeader::getValue)); - - assertThat(headers).hasSize(expectedHeaders.size()); - assertThat(headers).containsAllEntriesOf(expectedHeaders); - } - - private void assertContentEqual(HttpUriRequest request, String expectedContent) throws IOException { - assertThat(request).isInstanceOf(HttpUriRequestBase.class); - - InputStreamReader inputStreamReader = new InputStreamReader(((HttpUriRequestBase) request).getEntity().getContent(), StandardCharsets.UTF_8); - String content = new BufferedReader(inputStreamReader).readLine(); - - assertThat(content).isEqualTo(expectedContent); - } - - private void assertContentEmpty(HttpUriRequest request) { - assertThat(request).isInstanceOfAny(HttpGet.class, HttpHead.class, HttpDelete.class); - } -} diff --git a/src/test/java/io/weaviate/client/base/util/BeaconPathTest.java b/src/test/java/io/weaviate/client/base/util/BeaconPathTest.java deleted file mode 100644 index d35f2732f..000000000 --- a/src/test/java/io/weaviate/client/base/util/BeaconPathTest.java +++ /dev/null @@ -1,247 +0,0 @@ -package io.weaviate.client.base.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class BeaconPathTest { - - private AutoCloseable openedMocks; - @InjectMocks - private BeaconPath beaconPath; - @Mock - private DbVersionSupport dbVersionSupportMock; - - private static final BeaconPath.Params EMPTY_PARAMS = BeaconPath.Params.builder().build(); - private static final BeaconPath.Params CLASS_PARAMS = BeaconPath.Params.builder() - .className("someClass") - .build(); - private static final BeaconPath.Params ID_PARAMS = BeaconPath.Params.builder() - .id("someId") - .build(); - private static final BeaconPath.Params PROPERTY_PARAMS = BeaconPath.Params.builder() - .property("someProperty") - .build(); - private static final BeaconPath.Params ALL_PARAMS = BeaconPath.Params.builder() - .className("someClass") - .id("someId") - .property("someProperty") - .build(); - - @Before - public void setUp() { - openedMocks = MockitoAnnotations.openMocks(this); - } - @After - public void tearDown() throws Exception { - openedMocks.close(); - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideForSingleSupported") - public void shouldBuildSinglePathsWhenSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(beaconPath.buildSingle(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideForSingleSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost/someClass" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ALL_PARAMS, - "weaviate://localhost/someClass/someId" - }, - }; - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideSingleForNotSupported") - public void shouldBuildSinglePathsWhenNotSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(beaconPath.buildSingle(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideSingleForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ALL_PARAMS, - "weaviate://localhost/someId" - }, - }; - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideForBatchFromSupported") - public void shouldBuildBatchFromPathsWhenSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(beaconPath.buildBatchFrom(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideForBatchFromSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost/someClass" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost/someProperty" - }, - { - ALL_PARAMS, - "weaviate://localhost/someClass/someId/someProperty" - }, - }; - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideBatchFromForNotSupported") - public void shouldBuildBatchFromPathsWhenNotSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(beaconPath.buildBatchFrom(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideBatchFromForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost/someClass" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost/someProperty" - }, - { - ALL_PARAMS, - "weaviate://localhost/someClass/someId/someProperty" - }, - }; - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideForBatchToSupported") - public void shouldBuildBatchToPathsWhenSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(beaconPath.buildBatchTo(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideForBatchToSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost/someClass" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ALL_PARAMS, - "weaviate://localhost/someClass/someId" - }, - }; - } - - @Test - @DataMethod(source = BeaconPathTest.class, method = "provideBatchToForNotSupported") - public void shouldBuildBatchToPathsWhenNotSupported(BeaconPath.Params pathParams, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(beaconPath.buildBatchTo(pathParams)).isEqualTo(expectedPath); - } - - public static Object[][] provideBatchToForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - CLASS_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ID_PARAMS, // TODO should be valid? - "weaviate://localhost/someId" - }, - { - PROPERTY_PARAMS, // TODO should be valid? - "weaviate://localhost" - }, - { - ALL_PARAMS, - "weaviate://localhost/someId" - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/base/util/CrossReferenceTest.java b/src/test/java/io/weaviate/client/base/util/CrossReferenceTest.java deleted file mode 100644 index d51403d3e..000000000 --- a/src/test/java/io/weaviate/client/base/util/CrossReferenceTest.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.base.util; - -import org.junit.Test; -import static org.assertj.core.api.Assertions.assertThat; - -public class CrossReferenceTest { - - @Test - public void testParseBeaconWithClass() { - // given - String beacon = "weaviate://localhost/RefClass/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"; - // when - CrossReference crossRef = CrossReference.fromBeacon(beacon); - // then - assertThat(crossRef).isNotNull().satisfies(cf -> { - assertThat(cf.isLocal()).isTrue(); - assertThat(cf.getPeerName()).isEqualTo("localhost"); - assertThat(cf.getClassName()).isEqualTo("RefClass"); - assertThat(cf.getTargetID()).isEqualTo("f81bfe5e-16ba-4615-a516-46c2ae2e5a80"); - }); - } - - @Test - public void testParseBeaconWithoutClass() { - // given - String beacon = "weaviate://localhost/f81bfe5e-16ba-4615-a516-46c2ae2e5a80"; - // when - CrossReference crossRef = CrossReference.fromBeacon(beacon); - // then - assertThat(crossRef).isNotNull().satisfies(cf -> { - assertThat(cf.isLocal()).isTrue(); - assertThat(cf.getPeerName()).isEqualTo("localhost"); - assertThat(cf.getClassName()).isEqualTo(""); - assertThat(cf.getTargetID()).isEqualTo("f81bfe5e-16ba-4615-a516-46c2ae2e5a80"); - }); - } - - @Test - public void testParseBeaconEmpty() { - // given - String beacon = ""; - // when - CrossReference crossRef = CrossReference.fromBeacon(beacon); - // then - assertThat(crossRef).isNull(); - } -} diff --git a/src/test/java/io/weaviate/client/base/util/DbVersionProviderTest.java b/src/test/java/io/weaviate/client/base/util/DbVersionProviderTest.java deleted file mode 100644 index 79d178fd5..000000000 --- a/src/test/java/io/weaviate/client/base/util/DbVersionProviderTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package io.weaviate.client.base.util; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.Optional; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(MockitoJUnitRunner.class) -public class DbVersionProviderTest { - - public static final String VERSION_1 = "1.2.3"; - public static final String VERSION_2 = "2.3.4"; - @InjectMocks - private DbVersionProvider dbVersionProvider; - @Mock - private DbVersionProvider.VersionGetter versionGetterMock; - - - @Test - public void shouldReturnEmptyVersion() { - Mockito.when(versionGetterMock.get()).thenReturn(Optional.empty()); - - assertThat(dbVersionProvider.getVersion()).isEmpty(); - } - - @Test - public void shouldReturnProperVersion() { - Mockito.when(versionGetterMock.get()).thenReturn(Optional.of(VERSION_1)); - - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_1); - } - - @Test - public void shouldReturnNewVersionAfterRefresh() { - Mockito.when(versionGetterMock.get()).thenReturn(Optional.of(VERSION_1), Optional.of(VERSION_2)); - - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_1); - dbVersionProvider.refresh(true); - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_2); - } - - @Test - public void shouldFetchVersionOnce() { - Mockito.when(versionGetterMock.get()).thenReturn(Optional.of(VERSION_1)); - - dbVersionProvider.getVersion(); - dbVersionProvider.getVersion(); - dbVersionProvider.getVersion(); - - Mockito.verify(versionGetterMock, Mockito.times(1)).get(); - } - - @Test - public void shouldFetchVersionUntilSuccess() { - Mockito.when(versionGetterMock.get()).thenReturn(Optional.empty(), Optional.empty(), Optional.of(VERSION_1)); - - assertThat(dbVersionProvider.getVersion()).isEmpty(); - assertThat(dbVersionProvider.getVersion()).isEmpty(); - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_1); - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_1); - assertThat(dbVersionProvider.getVersion()).isEqualTo(VERSION_1); - - Mockito.verify(versionGetterMock, Mockito.times(3)).get(); - } - -} diff --git a/src/test/java/io/weaviate/client/base/util/DbVersionSupportTest.java b/src/test/java/io/weaviate/client/base/util/DbVersionSupportTest.java deleted file mode 100644 index 7e4fa9d1d..000000000 --- a/src/test/java/io/weaviate/client/base/util/DbVersionSupportTest.java +++ /dev/null @@ -1,68 +0,0 @@ -package io.weaviate.client.base.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class DbVersionSupportTest { - - private AutoCloseable openedMocks; - @InjectMocks - private DbVersionSupport dbVersionSupport; - @Mock - private DbVersionProvider dbVersionProviderMock; - - @Before - public void setUp() { - openedMocks = MockitoAnnotations.openMocks(this); - } - @After - public void tearDown() throws Exception { - openedMocks.close(); - } - - @Test - @DataMethod(source = DbVersionSupportTest.class, method = "provideNotSupported") - public void shouldNotSupport(String dbVersion) { - Mockito.when(dbVersionProviderMock.getVersion()).thenReturn(dbVersion); - - assertThat(dbVersionSupport.supportsClassNameNamespacedEndpoints()).isFalse(); - } - - public static Object[][] provideNotSupported() { - return new Object[][]{ - {"0.11"}, - {"1.13.9"}, - {"1.13"}, - {"1.0"}, - }; - } - - @Test - @DataMethod(source = DbVersionSupportTest.class, method = "provideSupported") - public void shouldSupport(String dbVersion) { - Mockito.when(dbVersionProviderMock.getVersion()).thenReturn(dbVersion); - - assertThat(dbVersionSupport.supportsClassNameNamespacedEndpoints()).isTrue(); - } - - public static Object[][] provideSupported() { - return new Object[][]{ - {"1.14.0"}, - {"1.14.9"}, - {"1.100"}, - {"2.0"}, - {"10.11.12"}, - }; - } -} diff --git a/src/test/java/io/weaviate/client/base/util/GrpcVersionSupportTest.java b/src/test/java/io/weaviate/client/base/util/GrpcVersionSupportTest.java deleted file mode 100644 index 3e1cd8616..000000000 --- a/src/test/java/io/weaviate/client/base/util/GrpcVersionSupportTest.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.client.base.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; - -@RunWith(JParamsTestRunner.class) -public class GrpcVersionSupportTest { - - private AutoCloseable openedMocks; - @InjectMocks - private GrpcVersionSupport grpcVersionProvider; - @Mock - private DbVersionProvider dbVersionProviderMock; - - @Before - public void setUp() { - openedMocks = MockitoAnnotations.openMocks(this); - } - - @After - public void tearDown() throws Exception { - openedMocks.close(); - } - - @Test - @DataMethod(source = GrpcVersionSupportTest.class, method = "provideNotSupported") - public void shouldNotSupportVectorBytes(String dbVersion) { - Mockito.when(dbVersionProviderMock.getVersion()).thenReturn(dbVersion); - - assertThat(grpcVersionProvider.supportsVectorBytesField()).isFalse(); - } - - public static Object[][] provideNotSupported() { - return new Object[][]{ - {"0.11"}, - {"1.13.9"}, - {"1.22.0-rc.0"}, - {"1.22.4"}, - {"1.22.5"}, - }; - } - - @Test - @DataMethod(source = GrpcVersionSupportTest.class, method = "provideSupported") - public void shouldSupportVectorBytes(String dbVersion) { - Mockito.when(dbVersionProviderMock.getVersion()).thenReturn(dbVersion); - - assertThat(grpcVersionProvider.supportsVectorBytesField()).isTrue(); - } - - public static Object[][] provideSupported() { - return new Object[][]{ - {"1.22.6"}, - {"1.23.0-rc.0"}, - {"1.23.10"}, - {"1.30.1"}, - {"1.31"}, - {"2.31"}, - {"10.11.12"}, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/auth/provider/AccessTokenProviderTest.java b/src/test/java/io/weaviate/client/v1/auth/provider/AccessTokenProviderTest.java deleted file mode 100644 index b9ab41bf0..000000000 --- a/src/test/java/io/weaviate/client/v1/auth/provider/AccessTokenProviderTest.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.auth.provider; - -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class AccessTokenProviderTest extends TestCase { - - @Test - public void testRefreshingOfToken() throws InterruptedException { - class AuthProviderImpl implements AccessTokenProvider { - private String accessToken; - private ScheduledExecutorService executor; - - public AuthProviderImpl(String accessToken, long period) { - this.accessToken = accessToken; - scheduleRefreshTokenTask(period); - } - - @Override - public String getAccessToken() { - return accessToken; - } - - @Override - public void shutdown() { - executor.shutdown(); - } - - private void scheduleRefreshTokenTask(long period) { - executor = Executors.newSingleThreadScheduledExecutor(); - executor.scheduleAtFixedRate(() -> accessToken = "NEW_VALUE", period, period, TimeUnit.SECONDS); - } - } - // given - AccessTokenProvider tokenProvider = new AuthProviderImpl("OLD_VALUE", 2); - // when then - Assert.assertEquals("OLD_VALUE", tokenProvider.getAccessToken()); - Thread.sleep(3000); - // will properly shutdown - tokenProvider.shutdown(); - Assert.assertEquals("NEW_VALUE", tokenProvider.getAccessToken()); - } -} diff --git a/src/test/java/io/weaviate/client/v1/batch/api/ObjectsBatcherTest.java b/src/test/java/io/weaviate/client/v1/batch/api/ObjectsBatcherTest.java deleted file mode 100644 index 0eb30b9bf..000000000 --- a/src/test/java/io/weaviate/client/v1/batch/api/ObjectsBatcherTest.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; - -import org.apache.http.HttpStatus; -import org.assertj.core.api.Assertions; -import org.junit.Test; -import org.junit.runner.RunWith; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.grpc.protocol.v1.WeaviateProtoBatch; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; - -@RunWith(JParamsTestRunner.class) -public class ObjectsBatcherTest { - public static Object[][] batchReplyTestCases() { - return new Object[][] { - { 1, 2 }, - { 0, 3 }, - { 3, 0 }, - { 2, 2 }, - }; - } - - @DataMethod(source = ObjectsBatcherTest.class, method = "batchReplyTestCases") - @Test - public void test_resultFromBatchObjectsReply(int wantSucceed, int wantFail) { - // Arrange - List batch = new ArrayList<>(); - int total = wantSucceed + wantFail; - for (int i = 0; i < total; i++) { - batch.add(WeaviateObject.builder().id("id-" + i).build()); - } - - WeaviateProtoBatch.BatchObjectsReply.Builder reply = WeaviateProtoBatch.BatchObjectsReply.newBuilder(); - for (int i = 0; i < wantFail; i++) { - reply.addErrors(WeaviateProtoBatch.BatchObjectsReply.BatchError.newBuilder() - .setIndex(i).setError("error-" + i) - .build()); - } - - Result got = ObjectsBatcher.resultFromBatchObjectsReply(reply.build(), batch); - - // Assert - List succeeded = Arrays.stream(got.getResult()) - .filter(result -> result.getResult().getErrors() == null) - .collect(Collectors.toList()); - List failed = Arrays.stream(got.getResult()) - .filter(result -> result.getResult().getErrors() != null) - .collect(Collectors.toList()); - Assertions.assertThat(got.getResult()).hasSize(total); - Assertions.assertThat(failed).hasSize(wantFail); - Assertions.assertThat(succeeded).hasSize(wantSucceed); - - if (wantFail == 0) { - Assertions.assertThat(got.getError()).isNull(); - return; - } - - String[] wantErrors = new String[wantFail]; - for (int i = 0; i < failed.size(); i++) { - wantErrors[i] = failed.get(i).getResult().getErrors().getError().get(0).getMessage(); - } - Assertions.assertThat(got.getError()).returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode); - Assertions.assertThat(got.getError().getMessages()) - .hasSize(wantFail) - .extracting(WeaviateErrorMessage::getMessage) - .contains(wantErrors); - - } -} diff --git a/src/test/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilderTest.java b/src/test/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilderTest.java deleted file mode 100644 index 954996249..000000000 --- a/src/test/java/io/weaviate/client/v1/batch/api/ReferencePayloadBuilderTest.java +++ /dev/null @@ -1,57 +0,0 @@ -package io.weaviate.client.v1.batch.api; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.v1.batch.model.BatchReference; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(MockitoJUnitRunner.class) -public class ReferencePayloadBuilderTest { - - @Mock - private BeaconPath beaconPathMock; - - @Before - public void setUp() { - Mockito.when(beaconPathMock.buildBatchFrom(Mockito.any(BeaconPath.Params.class))) - .thenReturn("weaviate://beacon-mock-batch-from"); - Mockito.when(beaconPathMock.buildBatchTo(Mockito.any(BeaconPath.Params.class))) - .thenReturn("weaviate://beacon-mock-batch-to"); - } - - @Test - public void shouldHaveBeaconsFromBeaconPath() { - ReferencePayloadBuilder builder = new ReferencePayloadBuilder(beaconPathMock) - .withFromID("someFromId") - .withFromClassName("someFromClass") - .withFromRefProp("someFromProperty") - .withToID("someToId") - .withToClassName("someToClass"); - - BatchReference payload = builder.payload(); - - assertThat(payload.getFrom()).isEqualTo("weaviate://beacon-mock-batch-from"); - assertThat(payload.getTo()).isEqualTo("weaviate://beacon-mock-batch-to"); - } - - @Test - public void shouldHaveDeprecatedBeacons() { - ReferencePayloadBuilder builder = new ReferencePayloadBuilder() - .withFromID("someFromId") - .withFromClassName("someFromClass") - .withFromRefProp("someFromProperty") - .withToID("someToId") - .withToClassName("someToClass"); - - BatchReference payload = builder.payload(); - - assertThat(payload.getFrom()).isEqualTo("weaviate://localhost/someFromClass/someFromId/someFromProperty"); - assertThat(payload.getTo()).isEqualTo("weaviate://localhost/someToId"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseTest.java b/src/test/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseTest.java deleted file mode 100644 index 7559d8292..000000000 --- a/src/test/java/io/weaviate/client/v1/batch/model/BatchReferenceResponseTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package io.weaviate.client.v1.batch.model; - -import com.google.gson.Gson; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStreamReader; -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class BatchReferenceResponseTest extends TestCase { - @Test - public void testDeserialization() throws FileNotFoundException { - // given - File jsonFile = new File("src/test/resources/json/batch-reference-response.json"); - InputStreamReader reader = new InputStreamReader(new FileInputStream(jsonFile)); - // when - BatchReferenceResponse[] resp = new Gson().fromJson(new BufferedReader(reader), BatchReferenceResponse[].class); - // then - Assert.assertNotNull(resp); - Assert.assertEquals(4, resp.length); - Assert.assertEquals("weaviate://localhost/Pizza/97fa5147-bdad-4d74-9a81-f8babc811b09/otherFoods", resp[0].getFrom()); - Assert.assertEquals("weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af", resp[0].getTo()); - Assert.assertEquals(BatchReferenceResponseStatus.SUCCESS, resp[0].getResult().getStatus()); - } -} diff --git a/src/test/java/io/weaviate/client/v1/batch/util/ObjectsPathTest.java b/src/test/java/io/weaviate/client/v1/batch/util/ObjectsPathTest.java deleted file mode 100644 index dac706fb8..000000000 --- a/src/test/java/io/weaviate/client/v1/batch/util/ObjectsPathTest.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.weaviate.client.v1.batch.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.Test; -import org.junit.runner.RunWith; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class ObjectsPathTest { - - private final ObjectsPath objectsPath = new ObjectsPath(); - - private static final ObjectsPath.Params EMPTY_PARAMS = ObjectsPath.Params.builder() - .build(); - private static final ObjectsPath.Params ALL_PARAMS = ObjectsPath.Params.builder() - .consistencyLevel(ConsistencyLevel.QUORUM) - .build(); - - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideCreate") - public void shouldBuildCreatePaths(ObjectsPath.Params params, String expectedPath) { - assertThat(objectsPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreate() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/batch/objects" - }, - { - ALL_PARAMS, - "/batch/objects?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideDelete") - public void shouldBuildDeletePaths(ObjectsPath.Params params, String expectedPath) { - assertThat(objectsPath.buildDelete(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideDelete() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/batch/objects" - }, - { - ALL_PARAMS, - "/batch/objects?consistency_level=QUORUM" - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/batch/util/ReferencesPathTest.java b/src/test/java/io/weaviate/client/v1/batch/util/ReferencesPathTest.java deleted file mode 100644 index f489bf3b7..000000000 --- a/src/test/java/io/weaviate/client/v1/batch/util/ReferencesPathTest.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.batch.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.Test; -import org.junit.runner.RunWith; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class ReferencesPathTest { - - private final ReferencesPath referencesPath = new ReferencesPath(); - - private static final ReferencesPath.Params EMPTY_PARAMS = ReferencesPath.Params.builder() - .build(); - private static final ReferencesPath.Params ALL_PARAMS = ReferencesPath.Params.builder() - .consistencyLevel(ConsistencyLevel.QUORUM) - .build(); - - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideCreate") - public void shouldBuildCreatePaths(ReferencesPath.Params params, String expectedPath) { - assertThat(referencesPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreate() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/batch/references" - }, - { - ALL_PARAMS, - "/batch/references?consistency_level=QUORUM" - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseTest.java b/src/test/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseTest.java deleted file mode 100644 index ca3fce131..000000000 --- a/src/test/java/io/weaviate/client/v1/contextionary/model/C11yWordsResponseTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.weaviate.client.v1.contextionary.model; - -import com.google.gson.Gson; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStreamReader; -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class C11yWordsResponseTest extends TestCase { - @Test - public void testDeserialization() throws FileNotFoundException { - // given - File jsonFile = new File("src/test/resources/json/c11y-concepts.json"); - InputStreamReader reader = new InputStreamReader(new FileInputStream(jsonFile)); - // when - C11yWordsResponse resp = new Gson().fromJson(new BufferedReader(reader), C11yWordsResponse.class); - // then - Assert.assertNotNull(resp); - Assert.assertEquals("pizzaHawaii", resp.getConcatenatedWord().getConcatenatedWord()); - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilderTest.java b/src/test/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilderTest.java deleted file mode 100644 index c5005384d..000000000 --- a/src/test/java/io/weaviate/client/v1/data/builder/ReferencePayloadBuilderTest.java +++ /dev/null @@ -1,47 +0,0 @@ -package io.weaviate.client.v1.data.builder; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; -import io.weaviate.client.base.util.BeaconPath; -import io.weaviate.client.v1.data.model.SingleRef; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(MockitoJUnitRunner.class) -public class ReferencePayloadBuilderTest { - - @Mock - private BeaconPath beaconPathMock; - - @Before - public void setUp() { - Mockito.when(beaconPathMock.buildSingle(Mockito.any(BeaconPath.Params.class))) - .thenReturn("weaviate://beacon-mock-single"); - } - - @Test - public void shouldHaveBeaconFromBeaconPath() { - ReferencePayloadBuilder builder = new ReferencePayloadBuilder(beaconPathMock) - .withID("someId") - .withClassName("someClass"); - - SingleRef payload = builder.payload(); - - assertThat(payload.getBeacon()).isEqualTo("weaviate://beacon-mock-single"); - } - - @Test - public void shouldHaveDeprecatedBeacon() { - ReferencePayloadBuilder builder = new ReferencePayloadBuilder() - .withID("someId") - .withClassName("someClass"); - - SingleRef payload = builder.payload(); - - assertThat(payload.getBeacon()).isEqualTo("weaviate://localhost/someId"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/model/ObjectTest.java b/src/test/java/io/weaviate/client/v1/data/model/ObjectTest.java deleted file mode 100644 index 34cecd8c6..000000000 --- a/src/test/java/io/weaviate/client/v1/data/model/ObjectTest.java +++ /dev/null @@ -1,115 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStreamReader; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.junit.Assert; -import org.junit.Test; - -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; - -import junit.framework.TestCase; - -public class ObjectTest extends TestCase { - @Test - public void testSerializeObject() { - // given - Map properties = new HashMap<>(); - properties.put("name", "Pizza"); - properties.put("description", "Italian pizzas"); - WeaviateObject obj = WeaviateObject.builder() - .id("uuid") - .className("class") - .creationTimeUnix(1000l) - .lastUpdateTimeUnix(2000l) - .vector(new Float[] { 1.0f, 2.0f }) - .properties(properties) - .build(); - // when - String result = new GsonBuilder().setPrettyPrinting().create().toJson(obj); - // then - Assert.assertNotNull(result); - } - - @Test - public void testDeserialization() throws FileNotFoundException { - // given - File jsonFile = new File("src/test/resources/json/object.json"); - InputStreamReader reader = new InputStreamReader(new FileInputStream(jsonFile)); - // when - WeaviateObject result = new Gson().fromJson(reader, WeaviateObject.class); - // then - Assert.assertNotNull(result); - Assert.assertNotNull(result.getId()); - Assert.assertNotNull(result.getProperties()); - Assert.assertNotNull(result.getProperties().get("name")); - Assert.assertNotNull(result.getProperties().get("description")); - Assert.assertNotNull(result.getAdditional()); - Assert.assertEquals(2, result.getAdditional().size()); - Assert.assertNull(result.getAdditional().get("classification")); - Assert.assertNotNull(result.getAdditional().get("nearestNeighbors")); - Assert.assertNotNull(result.getVector()); - } - - @Test - public void testDeserialization2() throws FileNotFoundException { - // given - File jsonFile = new File("src/test/resources/json/object2.json"); - InputStreamReader reader = new InputStreamReader(new FileInputStream(jsonFile)); - // when - WeaviateObject result = new Gson().fromJson(reader, WeaviateObject.class); - // then - Assert.assertNotNull(result); - Assert.assertNotNull(result.getId()); - Assert.assertNotNull(result.getProperties()); - Assert.assertNotNull(result.getProperties().get("name")); - Assert.assertNotNull(result.getProperties().get("description")); - Assert.assertNotNull(result.getProperties().get("otherFoods")); - Assert.assertTrue(result.getProperties().get("otherFoods") instanceof List); - List otherFoods = (List) result.getProperties().get("otherFoods"); - Assert.assertTrue(otherFoods.get(0) instanceof Map); - Map otherFood0 = (Map) otherFoods.get(0); - Map otherFood1 = (Map) otherFoods.get(1); - Assert.assertEquals("weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09", otherFood0.get("beacon")); - Assert.assertEquals("/v1/objects/97fa5147-bdad-4d74-9a81-f8babc811b09", otherFood0.get("href")); - Assert.assertEquals("weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af", otherFood1.get("beacon")); - Assert.assertEquals("/v1/objects/07473b34-0ab2-4120-882d-303d9e13f7af", otherFood1.get("href")); - } - - @Test - public void testSerializeWithReferenceProperty() { - // given - Map properties = new HashMap() { - { - put("name", "RefBeaconSoup"); - put("description", "Used only to check if reference can be added."); - put("otherFoods", new ObjectReference[] { - ObjectReference.builder() - .beacon("weaviate://localhost/someClass/abefd256-8574-442b-9293-9205193737ee") - .build() - }); - put("rating", "9/10"); - } - }; - WeaviateObject obj = WeaviateObject.builder() - .id("uuid") - .className("class") - .properties(properties) - .build(); - // when - String result = new GsonBuilder() - .setPrettyPrinting() - .create() - .toJson(obj); - // then - Assert.assertNotNull(result); - Assert.assertTrue(result.contains("otherFoods")); - Assert.assertTrue(result.contains("weaviate://localhost/someClass/abefd256-8574-442b-9293-9205193737ee")); - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/model/ObjectsListResponseTest.java b/src/test/java/io/weaviate/client/v1/data/model/ObjectsListResponseTest.java deleted file mode 100644 index 5dc43193f..000000000 --- a/src/test/java/io/weaviate/client/v1/data/model/ObjectsListResponseTest.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import com.google.gson.Gson; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStreamReader; -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class ObjectsListResponseTest extends TestCase { - @Test - public void testDeserialization() throws FileNotFoundException { - // given - File jsonFile = new File("src/test/resources/json/objects-list-response.json"); - InputStreamReader reader = new InputStreamReader(new FileInputStream(jsonFile)); - // when - ObjectsListResponse resp = new Gson().fromJson(reader, ObjectsListResponse.class); - // then - Assert.assertNotNull(resp); - Assert.assertNotNull(resp.getObjects()); - Assert.assertEquals(4, resp.getObjects().length); - Assert.assertEquals(4, resp.getTotalResults()); - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/model/WeaviateObjectAdapterTest.java b/src/test/java/io/weaviate/client/v1/data/model/WeaviateObjectAdapterTest.java deleted file mode 100644 index 966892dd6..000000000 --- a/src/test/java/io/weaviate/client/v1/data/model/WeaviateObjectAdapterTest.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.v1.data.model; - -import java.util.Collections; - -import org.assertj.core.api.Assertions; -import org.junit.Test; -import org.junit.runner.RunWith; - -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.JsonElement; -import com.google.gson.JsonParser; -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -@RunWith(JParamsTestRunner.class) -/** - * Test that WeaviateObject vectors are de-/serialized correctly. Specifically, - * single- and multi-vectors should be correctly combined under the "vectors" - * key in case any named vectors are present. - */ -public class WeaviateObjectAdapterTest { - private static final Gson gson = new GsonBuilder() - .registerTypeAdapter(WeaviateObject.class, WeaviateObject.Adapter.INSTANCE) - .create(); - - public static Object[][] testCasesJson() { - return new Object[][] { - { - WeaviateObject.builder().vector(new Float[] { 1f, 2f, 3f }).build(), - "{\"vector\":[1.0,2.0,3.0]}" - }, - { - WeaviateObject.builder().vectors(Collections.singletonMap("single", new Float[] { 1f, 2f, 3f })).build(), - "{\"vectors\":{\"single\":[1.0,2.0,3.0]}}" - }, - { - WeaviateObject.builder() - .multiVectors(Collections.singletonMap("multi", new Float[][] { - { 1f, 2f, 3f }, - { 4f, 5f, 6f }, - })) - .build(), - "{\"vectors\":{\"multi\":[[1.0,2.0,3.0],[4.0, 5.0, 6.0]]}}" - }, - { - WeaviateObject.builder() - .vectors(Collections.singletonMap("single", new Float[] { 1f, 2f, 3f })) - .multiVectors(Collections.singletonMap("multi", new Float[][] { - { 1f, 2f, 3f }, - { 4f, 5f, 6f }, - })) - .build(), - "{\"vectors\":{\"single\":[1.0,2.0,3.0],\"multi\":[[1.0,2.0,3.0],[4.0, 5.0, 6.0]]}}" - }, - }; - } - - @Test - @DataMethod(source = WeaviateObjectAdapterTest.class, method = "testCasesJson") - public void test_toJson(WeaviateObject in, String want) { - String got = gson.toJson(in); - assertSameJson(got, want); - } - - @Test - @DataMethod(source = WeaviateObjectAdapterTest.class, method = "testCasesJson") - public void test_fromJson(WeaviateObject want, String in) { - WeaviateObject got = gson.fromJson(in, WeaviateObject.class); - Assertions.assertThat(got).usingRecursiveComparison().isEqualTo(want); - } - - private void assertSameJson(String got, String want) { - JsonElement gotEl = JsonParser.parseString(got); - JsonElement wantEl = JsonParser.parseString(want); - Assertions.assertThat(gotEl).isEqualTo(wantEl); - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/util/ObjectsPathTest.java b/src/test/java/io/weaviate/client/v1/data/util/ObjectsPathTest.java deleted file mode 100644 index b1fc6bb77..000000000 --- a/src/test/java/io/weaviate/client/v1/data/util/ObjectsPathTest.java +++ /dev/null @@ -1,457 +0,0 @@ -package io.weaviate.client.v1.data.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class ObjectsPathTest { - - private AutoCloseable openedMocks; - @InjectMocks - private ObjectsPath objectsPath; - @Mock - private DbVersionSupport dbVersionSupportMock; - - private static final ObjectsPath.Params EMPTY_PARAMS = ObjectsPath.Params.builder() - .build(); - private static final ObjectsPath.Params CLASS_PARAMS = ObjectsPath.Params.builder() - .className("someClass") - .build(); - private static final ObjectsPath.Params ID_PARAMS = ObjectsPath.Params.builder() - .id("someId") - .build(); - private static final ObjectsPath.Params SOME_PARAMS = ObjectsPath.Params.builder() - .className("someClass") - .consistencyLevel(ConsistencyLevel.QUORUM) - .limit(10) - .build(); - private static final ObjectsPath.Params ALL_PARAMS = ObjectsPath.Params.builder() - .className("someClass") - .id("someId") - .limit(100) - .offset(0) - .after("00000000-0000-0000-0000-000000000000") - .additional(new String[]{"additional1", "additional2"}) - .consistencyLevel(ConsistencyLevel.QUORUM) - .nodeName("node1") - .build(); - - - @Before - public void setUp() { - openedMocks = MockitoAnnotations.openMocks(this); - } - @After - public void tearDown() throws Exception { - openedMocks.close(); - } - - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideCreateForSupported") - public void shouldBuildCreatePathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreateForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects" - }, - { - SOME_PARAMS, - "/objects?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideCreateForNotSupported") - public void shouldBuildCreatePathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreateForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects" - }, - { - SOME_PARAMS, - "/objects?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideDeleteForSupported") - public void shouldBuildDeletePathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildDelete(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideDeleteForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects/someClass" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects/someClass?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someClass/someId?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideDeleteForNotSupported") - public void shouldBuildDeletePathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildDelete(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideDeleteForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someId?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideCheckForSupported") - public void shouldBuildCheckPathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildCheck(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCheckForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects/someClass" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects/someClass" - }, - { - ALL_PARAMS, - "/objects/someClass/someId" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideCheckForNotSupported") - public void shouldBuildCheckPathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildCheck(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCheckForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects" - }, - { - ALL_PARAMS, - "/objects/someId" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideGetOneForSupported") - public void shouldBuildGetOnePathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildGetOne(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideGetOneForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects/someClass" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects/someClass?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someClass/someId?include=additional1,additional2&consistency_level=QUORUM&node_name=node1" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideGetOneForNotSupported") - public void shouldBuildGetOnePathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildGetOne(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideGetOneForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someId?include=additional1,additional2&consistency_level=QUORUM&node_name=node1" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideGetForSupported") - public void shouldBuildGetPathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildGet(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideGetForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects?class=someClass" - }, - { - ID_PARAMS, - "/objects" - }, - { - SOME_PARAMS, - "/objects?class=someClass&limit=10" - }, - { - ALL_PARAMS, - "/objects?include=additional1,additional2&limit=100&offset=0&after=00000000-0000-0000-0000-000000000000" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideGetForNotSupported") - public void shouldBuildGetPathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildGet(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideGetForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects" - }, - { - SOME_PARAMS, - "/objects?limit=10" - }, - { - ALL_PARAMS, - "/objects?include=additional1,additional2&limit=100&offset=0&after=00000000-0000-0000-0000-000000000000" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideUpdateForSupported") - public void shouldBuildUpdatePathsWhenSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(objectsPath.buildUpdate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideUpdateForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects/someClass" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects/someClass?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someClass/someId?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ObjectsPathTest.class, method = "provideUpdateForNotSupported") - public void shouldBuildUpdatePathsWhenNotSupported(ObjectsPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(objectsPath.buildUpdate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideUpdateForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects" - }, - { - CLASS_PARAMS, - "/objects" - }, - { - ID_PARAMS, - "/objects/someId" - }, - { - SOME_PARAMS, - "/objects?consistency_level=QUORUM" - }, - { - ALL_PARAMS, - "/objects/someId?consistency_level=QUORUM" - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/data/util/ReferencesPathTest.java b/src/test/java/io/weaviate/client/v1/data/util/ReferencesPathTest.java deleted file mode 100644 index 5e5df2014..000000000 --- a/src/test/java/io/weaviate/client/v1/data/util/ReferencesPathTest.java +++ /dev/null @@ -1,253 +0,0 @@ -package io.weaviate.client.v1.data.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; -import io.weaviate.client.base.util.DbVersionSupport; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class ReferencesPathTest { - - private AutoCloseable openedMocks; - @InjectMocks - private ReferencesPath referencesPath; - @Mock - private DbVersionSupport dbVersionSupportMock; - - private static final ReferencesPath.Params EMPTY_PARAMS = ReferencesPath.Params.builder() - .build(); - private static final ReferencesPath.Params CLASS_PARAMS = ReferencesPath.Params.builder() - .className("someClass") - .build(); - private static final ReferencesPath.Params ID_PARAMS = ReferencesPath.Params.builder() - .id("someId") - .build(); - private static final ReferencesPath.Params PROPERTY_PARAMS = ReferencesPath.Params.builder() - .property("someProperty") - .build(); - private static final ReferencesPath.Params ALL_PARAMS = ReferencesPath.Params.builder() - .className("someClass") - .id("someId") - .property("someProperty") - .consistencyLevel(ConsistencyLevel.QUORUM) - .build(); - - - @Before - public void setUp() { - openedMocks = MockitoAnnotations.openMocks(this); - } - @After - public void tearDown() throws Exception { - openedMocks.close(); - } - - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideCreateForSupported") - public void shouldBuildCreatePathsWhenSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(referencesPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreateForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/someClass/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someClass/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideCreateForNotSupported") - public void shouldBuildCreatePathsWhenNotSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(referencesPath.buildCreate(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideCreateForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideDeleteForSupported") - public void shouldBuildDeletePathsWhenSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(referencesPath.buildDelete(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideDeleteForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/someClass/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someClass/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideDeleteForNotSupported") - public void shouldBuildDeletePathsWhenNotSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(referencesPath.buildDelete(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideDeleteForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideReplaceForSupported") - public void shouldBuildReplacePathsWhenSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(true); - - assertThat(referencesPath.buildReplace(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideReplaceForSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/someClass/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someClass/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } - - @Test - @DataMethod(source = ReferencesPathTest.class, method = "provideReplaceForNotSupported") - public void shouldBuildReplacePathsWhenNotSupported(ReferencesPath.Params params, String expectedPath) { - Mockito.when(dbVersionSupportMock.supportsClassNameNamespacedEndpoints()).thenReturn(false); - - assertThat(referencesPath.buildReplace(params)).isEqualTo(expectedPath); - } - - public static Object[][] provideReplaceForNotSupported() { - return new Object[][]{ - { - EMPTY_PARAMS, - "/objects/references" - }, - { - CLASS_PARAMS, - "/objects/references" - }, - { - ID_PARAMS, - "/objects/someId/references" - }, - { - PROPERTY_PARAMS, - "/objects/references/someProperty" - }, - { - ALL_PARAMS, - "/objects/someId/references/someProperty?consistency_level=QUORUM" - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponseTest.java b/src/test/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponseTest.java deleted file mode 100644 index 483f8d23c..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/model/GraphQLTypedResponseTest.java +++ /dev/null @@ -1,86 +0,0 @@ -package io.weaviate.client.v1.graphql.model; - -import com.google.gson.annotations.SerializedName; -import com.google.gson.reflect.TypeToken; -import io.weaviate.client.base.Serializer; -import java.io.IOException; -import java.lang.reflect.Type; -import java.nio.file.Files; -import java.nio.file.Paths; -import java.util.List; -import lombok.Getter; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.Test; - -public class GraphQLTypedResponseTest { - - @Test - public void testGraphQLGetResponse() throws IOException { - // given - Serializer s = new Serializer(); - String json = new String(Files.readAllBytes(Paths.get("src/test/resources/json/graphql-response.json"))); - // when - Type responseType = TypeToken.getParameterized(GraphQLTypedResponse.class, Soups.class).getType(); - GraphQLTypedResponse resp = s.toResponse(json, responseType); - // - assertThat(resp).isNotNull() - .extracting(o -> o.getData().getObjects().getSoups()) - .extracting(o -> o.get(0)).isNotNull() - .extracting(Soups.Soup::getName).isEqualTo("JustSoup"); - } - - @Test - public void testGraphQLGetResponseSoups() throws IOException { - // given - Serializer s = new Serializer(); - String json = new String(Files.readAllBytes(Paths.get("src/test/resources/json/graphql-response.json"))); - // when - GraphQLTypedResponse resp = s.toGraphQLTypedResponse(json, Soups.class); - // - assertThat(resp).isNotNull() - .extracting(o -> o.getData().getObjects().getSoups()) - .extracting(o -> o.get(0)).isNotNull() - .extracting(Soups.Soup::getName).isEqualTo("JustSoup"); - } - - @Test - public void testGraphQLGetResponseSoups2() throws IOException { - // given - Serializer s = new Serializer(); - String json = new String(Files.readAllBytes(Paths.get("src/test/resources/json/graphql-group-by-response.json"))); - // when - GraphQLTypedResponse resp = s.toGraphQLTypedResponse(json, Passages.class); - // then - assertThat(resp).isNotNull() - .extracting(o -> o.getData().getObjects().getPassages()) - .extracting(o -> o.get(0)).isNotNull() - .extracting(GraphQLGetBaseObject::getAdditional).isNotNull() - .extracting(GraphQLGetBaseObject.Additional::getGroup).isNotNull() - .extracting(GraphQLGetBaseObject.Additional.Group::getHits).isNotNull() - .extracting(o -> o.get(0)).isNotNull() - .extracting(GraphQLGetBaseObject.Additional.Group.GroupHit::getProperties).isNotNull() - .extracting(o -> o.get("name")).isEqualTo("test-name"); - } -} - -@Getter -class Soups { - @SerializedName(value = "Soup") - List soups; - - @Getter - public static class Soup extends GraphQLGetBaseObject { - String name; - } -} - -@Getter -class Passages { - @SerializedName(value = "Passage") - List passages; - - @Getter - public static class Passage extends GraphQLGetBaseObject { - String name; - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/AskArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/AskArgumentTest.java deleted file mode 100644 index fe160dc85..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/AskArgumentTest.java +++ /dev/null @@ -1,172 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class AskArgumentTest { - - @Test - public void testBuild() { - // given - String question = "What's your name?"; - // when - String arg = AskArgument.builder().question(question).build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\"}", arg); - } - - @Test - public void testBuildWithProperties() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - // when - String arg = AskArgument.builder() - .question(question).properties(properties) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"]}", arg); - } - - @Test - public void testBuildWithPropertiesAndCertainty() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float certainty = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).certainty(certainty) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] certainty:0.8}", arg); - } - - @Test - public void testBuildWithPropertiesAndDistance() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float distance = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).distance(distance) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] distance:0.8}", arg); - } - - @Test - public void testBuildWithAutocorrect() { - // given - String question = "What's your name?"; - // when - String arg = AskArgument.builder().question(question).autocorrect(true).build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" autocorrect:true}", arg); - } - - @Test - public void testBuildWithPropertiesAndCertaintyAndAutocorrect() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float certainty = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).certainty(certainty).autocorrect(false) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] certainty:0.8 autocorrect:false}", arg); - } - - @Test - public void testBuildWithPropertiesAndDistanceAndAutocorrect() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float distance = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).distance(distance).autocorrect(false) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] distance:0.8 autocorrect:false}", arg); - } - - @Test - public void testBuildWithPropertiesAndCertaintyAndAutocorrectAndRerank() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float certainty = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).certainty(certainty).autocorrect(false).rerank(true) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] certainty:0.8 autocorrect:false rerank:true}", arg); - } - - @Test - public void testBuildWithPropertiesAndDistanceAndAutocorrectAndRerank() { - // given - String question = "What's your name?"; - String[] properties = new String[]{ "prop1", "prop2" }; - Float distance = 0.8f; - // when - String arg = AskArgument.builder() - .question(question).properties(properties).distance(distance).autocorrect(false).rerank(true) - .build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" properties:[\"prop1\",\"prop2\"] distance:0.8 autocorrect:false rerank:true}", arg); - } - - @Test - public void testBuildWithRerank() { - // given - String question = "What's your name?"; - // when - String arg = AskArgument.builder().question(question).rerank(false).build().build(); - // then - assertNotNull(arg); - assertEquals("ask:{question:\"What's your name?\" rerank:false}", arg); - } - - @Test - public void testBuildWithoutAll() { - // given - // when - String arg = AskArgument.builder().build().build(); - // then - // builder will return a faulty ask arg in order for Weaviate to error - // so that user will know that something was wrong - assertNotNull(arg); - assertEquals("ask:{}", arg); - } - - @Test - public void shouldCreateArgumentWithChars() { - AskArgument ask = AskArgument.builder() - .question("What's \"your\" {'`:name:`'}?") - .properties(new String[]{"prop:\"'`{0}`'\""}) - .build(); - - String str = ask.build(); - - assertThat(str).isEqualTo("ask:{question:\"What's \\\"your\\\" {'`:name:`'}?\" " + - "properties:[\"prop:\\\"'`{0}`'\\\"\"]}"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/Bm25ArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/Bm25ArgumentTest.java deleted file mode 100644 index 2189366b0..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/Bm25ArgumentTest.java +++ /dev/null @@ -1,69 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.junit.Test; - -public class Bm25ArgumentTest { - - @Test - public void shouldCreateArgument() { - Bm25Argument bm25 = Bm25Argument.builder() - .query("I'm a simple string") - .build(); - - String str = bm25.build(); - - assertThat(str).isEqualTo("bm25:{query:\"I'm a simple string\"}"); - } - - @Test - public void shouldCreateArgumentWithProperties() { - Bm25Argument bm25 = Bm25Argument.builder() - .query("I'm a simple string") - .properties(new String[] { "prop1", "prop2" }) - .build(); - - String str = bm25.build(); - - assertThat(str).isEqualTo("bm25:{query:\"I'm a simple string\" " + - "properties:[\"prop1\",\"prop2\"]}"); - } - - @Test - public void shouldCreateArgumentWithSearchOperator_And() { - Bm25Argument bm25 = Bm25Argument.builder() - .query("hello") - .searchOperator(Bm25Argument.SearchOperator.and()) - .build(); - - String str = bm25.build(); - - assertThat(str).isEqualTo("bm25:{query:\"hello\" searchOperator:{operator:And minimumOrTokensMatch:0}}"); - } - - @Test - public void shouldCreateArgumentWithSearchOperator_Or() { - Bm25Argument bm25 = Bm25Argument.builder() - .query("hello") - .searchOperator(Bm25Argument.SearchOperator.or(2)) - .build(); - - String str = bm25.build(); - - assertThat(str).isEqualTo("bm25:{query:\"hello\" searchOperator:{operator:Or minimumOrTokensMatch:2}}"); - } - - @Test - public void shouldCreateArgumentWithChars() { - Bm25Argument bm25 = Bm25Argument.builder() - .query("\"I'm a complex string\" says the {'`:string:`'}") - .properties(new String[] { "prop:\"'`{0}`'\"" }) - .build(); - - String str = bm25.build(); - - assertThat(str).isEqualTo("bm25:{query:\"\\\"I'm a complex string\\\" says the {'`:string:`'}\" " + - "properties:[\"prop:\\\"'`{0}`'\\\"\"]}"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupArgumentTest.java deleted file mode 100644 index 2de1218c6..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupArgumentTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -public class GroupArgumentTest { - - @Test - public void testBuildWithAllParameters() { - // given - String expected = "group:{type:merge force:0.05}"; - GroupArgument groupArgument = GroupArgument.builder().type(GroupType.merge).force(0.05f).build(); - // when - String result = groupArgument.build(); - // then - assertEquals(expected, result); - } - - @Test - public void testBuildWithType() { - // given - String expected = "group:{type:closest}"; - GroupArgument groupArgument = GroupArgument.builder().type(GroupType.closest).build(); - // when - String result = groupArgument.build(); - // then - assertEquals(expected, result); - } - - @Test - public void testBuildWithForce() { - // given - String expected = "group:{force:0.9}"; - GroupArgument groupArgument = GroupArgument.builder().force(0.90f).build(); - // when - String result = groupArgument.build(); - // then - assertEquals(expected, result); - } - - @Test - public void testBuildWithoutAll() { - // given - GroupArgument groupArgument = GroupArgument.builder().build(); - // when - String result = groupArgument.build(); - // then - // builder will return a faulty group arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("group:{}", result); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgumentTest.java deleted file mode 100644 index bdaaf5487..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/GroupByArgumentTest.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import org.junit.Test; - -public class GroupByArgumentTest { - - @Test - public void testBuild() { - // given - // when - String arg = GroupByArgument.builder() - .path(new String[]{ "path" }) - .groups(1) - .objectsPerGroup(2).build().build(); - // then - assertNotNull(arg); - assertEquals("groupBy:{path:[\"path\"] groups:1 objectsPerGroup:2}", arg); - } - - @Test - public void testBuildOnlyPath() { - // given - // when - String arg = GroupByArgument.builder() - .path(new String[]{ "path" }) - .build().build(); - // then - assertNotNull(arg); - assertEquals("groupBy:{path:[\"path\"]}", arg); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/HybridArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/HybridArgumentTest.java deleted file mode 100644 index ecc37bcab..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/HybridArgumentTest.java +++ /dev/null @@ -1,162 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.LinkedHashMap; - -import org.junit.Test; -import org.junit.runner.RunWith; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -@RunWith(JParamsTestRunner.class) -public class HybridArgumentTest { - public static Object[][] provideTestCases() { - return new Object[][] { - { - "simple query", - HybridArgument.builder() - .query("I'm a simple string") - .build(), - "hybrid:{query:\"I'm a simple string\"}" - }, - { - "vector and alpha", - HybridArgument.builder() - .query("I'm a simple string") - .vector(new Float[] { .1f, .2f, .3f }) - .alpha(.567f) - .build(), - "hybrid:{query:\"I'm a simple string\" vector:[0.1,0.2,0.3] alpha:0.567}" - }, - { - "vector and target vectors", - HybridArgument.builder() - .query("I'm a simple string") - .vector(new Float[] { .1f, .2f, .3f }) - .targetVectors(new String[] { "vector1" }) - .build(), - "hybrid:{query:\"I'm a simple string\" vector:[0.1,0.2,0.3] targetVectors:[\"vector1\"]}" - }, - { - "with escaped characters", - HybridArgument.builder() - .query("\"I'm a complex string\" says the {'`:string:`'}") - .build(), - "hybrid:{query:\"\\\"I'm a complex string\\\" says the {'`:string:`'}\"}" - }, - { - "fusion type ranked", - HybridArgument.builder() - .query("I'm a simple string") - .fusionType(FusionType.RANKED) - .build(), - "hybrid:{query:\"I'm a simple string\" fusionType:rankedFusion}" - }, - { - "fusion type relative score", - HybridArgument.builder() - .query("I'm a simple string") - .fusionType(FusionType.RELATIVE_SCORE) - .build(), - "hybrid:{query:\"I'm a simple string\" fusionType:relativeScoreFusion}" - }, - { - "specify properties to search on", - HybridArgument.builder() - .query("I'm a simple string") - .properties(new String[] { "prop1", "prop2" }) - .build(), - "hybrid:{query:\"I'm a simple string\" properties:[\"prop1\",\"prop2\"]}" - }, - { - "nearVector search", - HybridArgument.builder().query("I'm a simple string") - .searches(HybridArgument.Searches.builder() - .nearVector(NearVectorArgument.builder() - .vector(new Float[] { .1f, .2f, .3f }) - .certainty(0.9f) - .build()) - .build()) - .build(), - "hybrid:{query:\"I'm a simple string\" searches:{nearVector:{vector:[0.1,0.2,0.3] certainty:0.9}}}" - }, - { - "nearText search", - HybridArgument.builder().query("I'm a simple string") - .searches( - HybridArgument.Searches.builder().nearText( - NearTextArgument.builder() - .concepts(new String[] { "concept" }) - .certainty(0.9f) - .build()) - .build()) - .build(), - "hybrid:{query:\"I'm a simple string\" searches:{nearText:{concepts:[\"concept\"] certainty:0.9}}}" - }, - { - "target vectors", - HybridArgument.builder().query("I'm a simple string") - .targets(Targets.builder() - .targetVectors(new String[] { "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.minimum) - .weights(new LinkedHashMap() { - { - put("t1", 0.8f); - put("t2", 0.2f); - } - }) - .build()) - .build(), - "hybrid:{query:\"I'm a simple string\" targets:{combinationMethod:minimum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}" - }, - { - "max vector distance", - HybridArgument.builder().query("I'm a simple string") - .searches(HybridArgument.Searches.builder().nearText( - NearTextArgument.builder().concepts(new String[] { "concept" }).build()).build()) - .maxVectorDistance(.5f) - .build(), - "hybrid:{query:\"I'm a simple string\" maxVectorDistance:0.5 searches:{nearText:{concepts:[\"concept\"]}}}" - }, - { - "multi-dimensional vector", - HybridArgument.builder().query("ColBERT me if you can!") - .searches(HybridArgument.Searches.builder().nearVector( - NearVectorArgument.builder() - .targetVectors(new String[] { "colbert" }) - .vector(new Float[][] { - { 1f, 2f, 3f }, - { 4f, 5f, 6f }, - }).build()) - .build()) - .build(), - "hybrid:{query:\"ColBERT me if you can!\" searches:{nearVector:{vector:[[1.0,2.0,3.0],[4.0,5.0,6.0]] targetVectors:[\"colbert\"]}}}", - }, - { - "bm25 search operator And", - HybridArgument.builder() - .query("hello") - .bm25SearchOperator(Bm25Argument.SearchOperator.and()) - .build(), - "hybrid:{query:\"hello\" bm25SearchOperator:{operator:And minimumOrTokensMatch:0}}", - }, - { - "bm25 search operator Or", - HybridArgument.builder() - .query("hello") - .bm25SearchOperator(Bm25Argument.SearchOperator.or(2)) - .build(), - "hybrid:{query:\"hello\" bm25SearchOperator:{operator:Or minimumOrTokensMatch:2}}", - }, - }; - } - - @DataMethod(source = HybridArgumentTest.class, method = "provideTestCases") - @Test - public void test(String name, HybridArgument hybrid, String expected) throws Exception { - String actual = hybrid.build(); - assertThat(actual).as(name).isEqualTo(expected); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgumentTest.java deleted file mode 100644 index 21954e7aa..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearAudioArgumentTest.java +++ /dev/null @@ -1,151 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearAudioArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearAudio = NearAudioArgument.builder() - .audioFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearAudio = NearAudioArgument.builder() - .audioFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearAudio = NearAudioArgument.builder() - .audioFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String audioBase64 = "iVBORw0KGgoAAAANS"; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\"}", audioBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String audioBase64 = "data:audio/mp4;base64,iVBORw0KGgoAAAANS"; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .build().build(); - - assertThat(nearAudio).isEqualTo("nearAudio:{audio:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String audioBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" certainty:%s}", audioBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String audioBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .distance(distance) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" distance:%s}", audioBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String audioBase64 = "iVBORw0KGgoAAAANS"; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" targetVectors:[\"vector1\"]}", audioBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearAudio = NearAudioArgument.builder() - .audioFile(badFile) - .build().build(); - - assertThat(nearAudio).isEqualTo("nearAudio:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearAudio = NearAudioArgument.builder() - .build().build(); - - assertThat(nearAudio).isEqualTo("nearAudio:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - // given - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.minimum) - .weights(weights) - .build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"concept"}).targets(targets).build(); - - String audioBase64 = "iVBORw0KGgoAAAANS"; - - String nearAudio = NearAudioArgument.builder() - .audio(audioBase64) - .targets(targets) - .build().build(); - - assertThat(nearAudio).isEqualTo(String.format("nearAudio:{audio:\"%s\" targets:{combinationMethod:minimum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", audioBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgumentTest.java deleted file mode 100644 index c332cbccc..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearDepthArgumentTest.java +++ /dev/null @@ -1,148 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearDepthArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearDepth = NearDepthArgument.builder() - .depthFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearDepth = NearDepthArgument.builder() - .depthFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearDepth = NearDepthArgument.builder() - .depthFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String depthBase64 = "iVBORw0KGgoAAAANS"; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\"}", depthBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String depthBase64 = "data:image/png;base64,iVBORw0KGgoAAAANS"; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .build().build(); - - assertThat(nearDepth).isEqualTo("nearDepth:{depth:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String depthBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" certainty:%s}", depthBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String depthBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .distance(distance) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" distance:%s}", depthBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String depthBase64 = "iVBORw0KGgoAAAANS"; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" targetVectors:[\"vector1\"]}", depthBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearDepth = NearDepthArgument.builder() - .depthFile(badFile) - .build().build(); - - assertThat(nearDepth).isEqualTo("nearDepth:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearDepth = NearDepthArgument.builder() - .build().build(); - - assertThat(nearDepth).isEqualTo("nearDepth:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.minimum) - .weights(weights) - .build(); - - String depthBase64 = "iVBORw0KGgoAAAANS"; - - String nearDepth = NearDepthArgument.builder() - .depth(depthBase64) - .targets(targets) - .build().build(); - - assertThat(nearDepth).isEqualTo(String.format("nearDepth:{depth:\"%s\" targets:{combinationMethod:minimum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", depthBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgumentTest.java deleted file mode 100644 index 31bf95987..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImageArgumentTest.java +++ /dev/null @@ -1,148 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearImageArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearImage = NearImageArgument.builder() - .imageFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearImage = NearImageArgument.builder() - .imageFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearImage = NearImageArgument.builder() - .imageFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String imageBase64 = "iVBORw0KGgoAAAANS"; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\"}", imageBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String imageBase64 = "data:image/mp4;base64,iVBORw0KGgoAAAANS"; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .build().build(); - - assertThat(nearImage).isEqualTo("nearImage:{image:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String imageBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" certainty:%s}", imageBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String imageBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .distance(distance) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" distance:%s}", imageBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String imageBase64 = "iVBORw0KGgoAAAANS"; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" targetVectors:[\"vector1\"]}", imageBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearImage = NearImageArgument.builder() - .imageFile(badFile) - .build().build(); - - assertThat(nearImage).isEqualTo("nearImage:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearImage = NearImageArgument.builder() - .build().build(); - - assertThat(nearImage).isEqualTo("nearImage:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.average) - .weights(weights) - .build(); - - String imageBase64 = "iVBORw0KGgoAAAANS"; - - String nearImage = NearImageArgument.builder() - .image(imageBase64) - .targets(targets) - .build().build(); - - assertThat(nearImage).isEqualTo(String.format("nearImage:{image:\"%s\" targets:{combinationMethod:average targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", imageBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgumentTest.java deleted file mode 100644 index 8258afc38..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearImuArgumentTest.java +++ /dev/null @@ -1,148 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearImuArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearImu = NearImuArgument.builder() - .imuFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearImu = NearImuArgument.builder() - .imuFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearImu = NearImuArgument.builder() - .imuFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String imuBase64 = "iVBORw0KGgoAAAANS"; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\"}", imuBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String imuBase64 = "data:image/png;base64,iVBORw0KGgoAAAANS"; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .build().build(); - - assertThat(nearImu).isEqualTo("nearIMU:{imu:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String imuBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" certainty:%s}", imuBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String imuBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .distance(distance) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" distance:%s}", imuBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String imuBase64 = "iVBORw0KGgoAAAANS"; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" targetVectors:[\"vector1\"]}", imuBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearImu = NearImuArgument.builder() - .imuFile(badFile) - .build().build(); - - assertThat(nearImu).isEqualTo("nearIMU:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearImu = NearImuArgument.builder() - .build().build(); - - assertThat(nearImu).isEqualTo("nearIMU:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.sum) - .weights(weights) - .build(); - - String imuBase64 = "iVBORw0KGgoAAAANS"; - - String nearImu = NearImuArgument.builder() - .imu(imuBase64) - .targets(targets) - .build().build(); - - assertThat(nearImu).isEqualTo(String.format("nearIMU:{imu:\"%s\" targets:{combinationMethod:sum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", imuBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelperTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelperTest.java deleted file mode 100644 index 0ed189f2a..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaArgumentHelperTest.java +++ /dev/null @@ -1,179 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearMediaArgumentHelperTest { - - public static File exampleMediaFile() { - return new File("src/test/resources/image/pixel.png"); - } - - public static String exampleMediaFileAsBase64() throws IOException { - Path path = Paths.get("src/test/resources/image/base64.txt"); - return String.join("\n", Files.readAllLines(path)); - } - - @Test - public void shouldBuildFromFile() throws IOException { - String nearMedia = NearMediaArgumentHelper.builder() - .dataFile(exampleMediaFile()) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\"}", exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearMedia = NearMediaArgumentHelper.builder() - .dataFile(exampleMediaFile()) - .certainty(certainty) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" certainty:%s}", exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearMedia = NearMediaArgumentHelper.builder() - .dataFile(exampleMediaFile()) - .distance(distance) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" distance:%s}", exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String mediaBase64 = "iVBORw0KGgoAAAANS"; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\"}", mediaBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String mediaBase64 = "data:image/png;base64,iVBORw0KGgoAAAANS"; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo("nearMedia:{media:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String mediaBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .certainty(certainty) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" certainty:%s}", mediaBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String mediaBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .distance(distance) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" distance:%s}", mediaBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String mediaBase64 = "iVBORw0KGgoAAAANS"; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .targetVectors(new String[]{"vector1"}) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" targetVectors:[\"vector1\"]}", mediaBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearMedia = NearMediaArgumentHelper.builder() - .dataFile(badFile) - .mediaField("media") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo("nearMedia:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearMedia = NearMediaArgumentHelper.builder() - .mediaField("whatever") - .mediaName("nearMedia") - .build().build(); - - assertThat(nearMedia).isEqualTo("nearMedia:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.manualWeights) - .weights(weights) - .build(); - - String mediaBase64 = "iVBORw0KGgoAAAANS"; - - String nearMedia = NearMediaArgumentHelper.builder() - .data(mediaBase64) - .mediaField("media") - .mediaName("nearMedia") - .targets(targets) - .build().build(); - - assertThat(nearMedia).isEqualTo(String.format("nearMedia:{media:\"%s\" targets:{combinationMethod:manualWeights targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", mediaBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaTargetsArgument.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaTargetsArgument.java deleted file mode 100644 index 79872acec..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearMediaTargetsArgument.java +++ /dev/null @@ -1,4 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -class NearMediaTargetsArgument { -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgumentTest.java deleted file mode 100644 index 65864ed9f..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearObjectArgumentTest.java +++ /dev/null @@ -1,137 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; - -public class NearObjectArgumentTest { - - @Test - public void testBuildWithCertainty() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").beacon("beacon").certainty(0.8f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" beacon:\"beacon\" certainty:0.8}", arg); - } - - @Test - public void testBuildWithoutCertainity() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").beacon("beacon") - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" beacon:\"beacon\"}", arg); - } - - @Test - public void testBuildWithDistance() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").beacon("beacon").distance(0.8f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" beacon:\"beacon\" distance:0.8}", arg); - } - - @Test - public void testBuildWithCertaintyAndWithoutId() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .beacon("beacon").certainty(0.4f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{beacon:\"beacon\" certainty:0.4}", arg); - } - - @Test - public void testBuildWithDistanceAndWithoutId() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .beacon("beacon").distance(0.4f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{beacon:\"beacon\" distance:0.4}", arg); - } - - @Test - public void testBuildWithCertaintyWithoutBeacon() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").certainty(0.1f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" certainty:0.1}", arg); - } - - @Test - public void testBuildWithDistanceWithoutBeacon() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").distance(0.1f) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" distance:0.1}", arg); - } - - @Test - public void testBuildWithoutAll() { - // given - NearObjectArgument nearObject = NearObjectArgument.builder().build(); - // when - String arg = nearObject.build(); - // then - // builder will return a faulty nearObject arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("nearObject:{}", arg); - } - - @Test - public void shouldBuildWithTargetVectors() { - String nearObject = NearObjectArgument.builder() - .id("id") - .beacon("beacon") - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearObject).isEqualTo("nearObject:{id:\"id\" beacon:\"beacon\" targetVectors:[\"vector1\"]}"); - } - - @Test - public void testBuildWithTargets() { - // given - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.relativeScore) - .weights(weights) - .build(); - NearObjectArgument nearObject = NearObjectArgument.builder() - .id("id").targets(targets) - .build(); - // when - String arg = nearObject.build(); - // then - assertEquals("nearObject:{id:\"id\" targets:{combinationMethod:relativeScore targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", arg); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgumentTest.java deleted file mode 100644 index 633ddc018..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearTextArgumentTest.java +++ /dev/null @@ -1,647 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; - -public class NearTextArgumentTest { - - @Test - public void testBuildWithCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8}", arg); - } - - @Test - public void testBuildWithDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8}", arg); - } - - @Test - public void testBuildWithCertaintyAndNoConcepts() { - // given - NearTextArgument nearText = NearTextArgument.builder() - .certainty(0.8f).build(); - // when - String arg = nearText.build(); - // then - // builder will return a faulty nearText arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("nearText:{certainty:0.8}", arg); - } - - @Test - public void testBuildWithDistanceAndNoConcepts() { - // given - NearTextArgument nearText = NearTextArgument.builder() - .distance(0.8f).build(); - // when - String arg = nearText.build(); - // then - // builder will return a faulty nearText arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("nearText:{distance:0.8}", arg); - } - - @Test - public void testBuildWithoutAll() { - // given - NearTextArgument nearText = NearTextArgument.builder().build(); - // when - String arg = nearText.build(); - // then - // builder will return a faulty nearText arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("nearText:{}", arg); - } - - @Test - public void testBuildMoveToWithCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveToWithDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveToWithCertaintyWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildMoveToWithDistanceWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildMoveAwayFromWithCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveAwayFromWithDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveAwayFromWithCertaintyWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildMoveAwayFromWithDistanceWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"] force:0.1}}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithCertaintyWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithDistanceWithoutForce() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"]}}", arg); - } - - @Test - public void testBuildWithAutocorrectAndCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).autocorrect(false).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 autocorrect:false}", arg); - } - - @Test - public void testBuildWithAutocorrectAndDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).autocorrect(false).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 autocorrect:false}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithCertaintyWithoutForceAndWithAutocorrect() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).autocorrect(true) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"]} autocorrect:true}", arg); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithDistanceWithoutForceAndWithAutocorrect() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "z1", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "a1", "b2" }).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).autocorrect(true) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 " + - "moveTo:{concepts:[\"z1\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"a1\",\"b2\"]} autocorrect:true}", arg); - } - - @Test - public void testBuildWithEmptyMoveToOrMoveAway() { - // given - NearTextMoveParameters move = NearTextMoveParameters.builder().build(); - NearTextArgument nearText1 = NearTextArgument.builder().moveTo(move).build(); - NearTextArgument nearText2 = NearTextArgument.builder().moveAwayFrom(move).build(); - NearTextArgument nearText3 = NearTextArgument.builder().moveTo(move).moveAwayFrom(move).build(); - // when - String arg1 = nearText1.build(); - String arg2 = nearText2.build(); - String arg3 = nearText3.build(); - // then - assertEquals("nearText:{moveTo:{}}", arg1); - assertEquals("nearText:{moveAwayFrom:{}}", arg2); - assertEquals("nearText:{moveTo:{} moveAwayFrom:{}}", arg3); - } - - @Test - public void testBuildMoveToWithObjectsAndCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo1 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveTo2 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveTo3 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - }) - .build(); - NearTextMoveParameters moveTo4 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build(), - }) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo1).build(); - NearTextArgument nearText2 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo2).build(); - NearTextArgument nearText3 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo3).build(); - NearTextArgument nearText4 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo4).build(); - // when - String arg1 = nearText1.build(); - String arg2 = nearText2.build(); - String arg3 = nearText3.build(); - String arg4 = nearText4.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]}}", arg1); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg2); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{objects:[{id:\"uuid\"}]}}", arg3); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{objects:[{beacon:\"beacon\"}]}}", arg4); - } - - @Test - public void testBuildMoveToWithObjectsAndDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo1 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveTo2 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveTo3 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - }) - .build(); - NearTextMoveParameters moveTo4 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build(), - }) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo1).build(); - NearTextArgument nearText2 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo2).build(); - NearTextArgument nearText3 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo3).build(); - NearTextArgument nearText4 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo4).build(); - // when - String arg1 = nearText1.build(); - String arg2 = nearText2.build(); - String arg3 = nearText3.build(); - String arg4 = nearText4.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]}}", arg1); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg2); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{objects:[{id:\"uuid\"}]}}", arg3); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{objects:[{beacon:\"beacon\"}]}}", arg4); - } - - @Test - public void testBuildMoveAwayWithObjectsAndCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAwayFrom1 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom2 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom3 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - }) - .build(); - NearTextMoveParameters moveAwayFrom4 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build(), - }) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAwayFrom1).build(); - NearTextArgument nearText2 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAwayFrom2).build(); - NearTextArgument nearText3 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAwayFrom3).build(); - NearTextArgument nearText4 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveAwayFrom(moveAwayFrom4).build(); - // when - String arg1 = nearText1.build(); - String arg2 = nearText2.build(); - String arg3 = nearText3.build(); - String arg4 = nearText4.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]}}", arg1); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{force:0.1 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg2); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{objects:[{id:\"uuid\"}]}}", arg3); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveAwayFrom:{objects:[{beacon:\"beacon\"}]}}", arg4); - } - - @Test - public void testBuildMoveAwayWithObjectsAndDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveAwayFrom1 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom2 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom3 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - }) - .build(); - NearTextMoveParameters moveAwayFrom4 = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build(), - }) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAwayFrom1).build(); - NearTextArgument nearText2 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAwayFrom2).build(); - NearTextArgument nearText3 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAwayFrom3).build(); - NearTextArgument nearText4 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveAwayFrom(moveAwayFrom4).build(); - // when - String arg1 = nearText1.build(); - String arg2 = nearText2.build(); - String arg3 = nearText3.build(); - String arg4 = nearText4.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]}}", arg1); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{force:0.1 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg2); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{objects:[{id:\"uuid\"}]}}", arg3); - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveAwayFrom:{objects:[{beacon:\"beacon\"}]}}", arg4); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithObjectsAndCertainty() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.2f) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f).moveTo(moveTo).moveAwayFrom(moveAwayFrom).build(); - // when - String arg1 = nearText1.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] certainty:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]} " + - "moveAwayFrom:{force:0.2 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg1); - } - - @Test - public void testBuildMoveToAndMoveAwayFromWithObjectsAndDistance() { - // given - String[] concepts = new String[]{ "a", "b", "c" }; - NearTextMoveParameters moveTo = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").build(), - NearTextMoveParameters.ObjectMove.builder().beacon("beacon").build() - }) - .force(0.1f) - .build(); - NearTextMoveParameters moveAwayFrom = NearTextMoveParameters - .builder() - .objects(new NearTextMoveParameters.ObjectMove[]{ - NearTextMoveParameters.ObjectMove.builder().id("uuid").beacon("beacon").build(), - }) - .force(0.2f) - .build(); - NearTextArgument nearText1 = NearTextArgument.builder() - .concepts(concepts).distance(0.8f).moveTo(moveTo).moveAwayFrom(moveAwayFrom).build(); - // when - String arg1 = nearText1.build(); - // then - assertEquals("nearText:{concepts:[\"a\",\"b\",\"c\"] distance:0.8 moveTo:{force:0.1 objects:[{id:\"uuid\"},{beacon:\"beacon\"}]} " + - "moveAwayFrom:{force:0.2 objects:[{id:\"uuid\" beacon:\"beacon\"}]}}", arg1); - } - - @Test - public void shouldCreateArgumentWithChars() { - // given - String[] concepts = new String[]{ "\"I'm a complex\" {'`:concept:`'}", "b" }; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{ "\"I'm a another complex\" {'`:concept:`'}", "y2" }).force(0.8f).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[]{ "\"I'm a yet another complex\" {'`:concept:`'}", "b2" }).force(0.1f).build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).certainty(0.8f) - .moveTo(moveTo).moveAwayFrom(moveAway).build(); - // when - String arg = nearText.build(); - // then - assertThat(arg).isEqualTo("nearText:{concepts:[\"\\\"I'm a complex\\\" {'`:concept:`'}\",\"b\"] certainty:0.8 " + - "moveTo:{concepts:[\"\\\"I'm a another complex\\\" {'`:concept:`'}\",\"y2\"] force:0.8} " + - "moveAwayFrom:{concepts:[\"\\\"I'm a yet another complex\\\" {'`:concept:`'}\",\"b2\"] force:0.1}}"); - } - - @Test - public void shouldBuildWithTargetVectors() { - String nearText = NearTextArgument.builder() - .concepts(new String[]{ "a", "b", "c" }) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearText).isEqualTo("nearText:{concepts:[\"a\",\"b\",\"c\"] targetVectors:[\"vector1\"]}"); - } - - @Test - public void testBuildWithTargets() { - // given - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.minimum) - .weights(weights) - .build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"concept"}).targets(targets).build(); - // when - String arg = nearText.build(); - // then - assertEquals("nearText:{concepts:[\"concept\"] targets:{combinationMethod:minimum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", arg); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgumentTest.java deleted file mode 100644 index 1f54f7e58..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearThermalArgumentTest.java +++ /dev/null @@ -1,148 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearThermalArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearThermal = NearThermalArgument.builder() - .thermalFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearThermal = NearThermalArgument.builder() - .thermalFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearThermal = NearThermalArgument.builder() - .thermalFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String thermalBase64 = "iVBORw0KGgoAAAANS"; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\"}", thermalBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String thermalBase64 = "data:image/png;base64,iVBORw0KGgoAAAANS"; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .build().build(); - - assertThat(nearThermal).isEqualTo("nearThermal:{thermal:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String thermalBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" certainty:%s}", thermalBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String thermalBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .distance(distance) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" distance:%s}", thermalBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String thermalBase64 = "iVBORw0KGgoAAAANS"; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" targetVectors:[\"vector1\"]}", thermalBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearThermal = NearThermalArgument.builder() - .thermalFile(badFile) - .build().build(); - - assertThat(nearThermal).isEqualTo("nearThermal:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearThermal = NearThermalArgument.builder() - .build().build(); - - assertThat(nearThermal).isEqualTo("nearThermal:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.minimum) - .weights(weights) - .build(); - - String thermalBase64 = "iVBORw0KGgoAAAANS"; - - String nearThermal = NearThermalArgument.builder() - .thermal(thermalBase64) - .targets(targets) - .build().build(); - - assertThat(nearThermal).isEqualTo(String.format("nearThermal:{thermal:\"%s\" targets:{combinationMethod:minimum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", thermalBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgumentTest.java deleted file mode 100644 index 2a1af2416..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVectorArgumentTest.java +++ /dev/null @@ -1,113 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; - -import java.util.LinkedHashMap; -import java.util.Map; - -import org.junit.Test; - -public class NearVectorArgumentTest { - - @Test - public void testBuildWithCertainty() { - // given - NearVectorArgument nearVector = NearVectorArgument.builder() - .vector(new Float[] { 1f, 2f, 3f }).certainty(0.8f).build(); - // when - String arg = nearVector.build(); - // then - assertEquals("nearVector:{vector:[1.0,2.0,3.0] certainty:0.8}", arg); - } - - @Test - public void testBuildWithDistance() { - // given - NearVectorArgument nearVector = NearVectorArgument.builder() - .vector(new Float[] { 1f, 2f, 3f }).distance(0.8f).build(); - // when - String arg = nearVector.build(); - // then - assertEquals("nearVector:{vector:[1.0,2.0,3.0] distance:0.8}", arg); - } - - @Test - public void testBuildWithNoCertainty() { - NearVectorArgument nearVector = NearVectorArgument.builder() - .vector(new Float[] { 1f, 2f, 3f }).build(); - // when - String arg = nearVector.build(); - // then - assertEquals("nearVector:{vector:[1.0,2.0,3.0]}", arg); - } - - @Test - public void shouldBuildWithTargetVectors() { - String nearVector = NearVectorArgument.builder() - .vector(new Float[] { 1f, 2f, 3f }) - .targetVectors(new String[] { "vector1" }) - .build().build(); - - assertThat(nearVector).isEqualTo("nearVector:{vector:[1.0,2.0,3.0] targetVectors:[\"vector1\"]}"); - } - - @Test - public void testBuildWithTargets() { - // given - LinkedHashMap vectorPerTarget = new LinkedHashMap<>(); - vectorPerTarget.put("t1", new Float[] { 1f, 2f, 3f }); - vectorPerTarget.put("t2", new Float[] { .1f, .2f, .3f }); - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[] { "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.sum) - .weights(weights) - .build(); - NearVectorArgument nearVector = NearVectorArgument.builder() - .vectorPerTarget(vectorPerTarget) - .targets(targets) - .build(); - // when - String arg = nearVector.build(); - // then - assertEquals( - "nearVector:{vectorPerTarget:{t1:[1.0,2.0,3.0] t2:[0.1,0.2,0.3]} targets:{combinationMethod:sum targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", - arg); - } - - @Test - public void testBuildWithMultipleVectorsPerTarget() { - Map vectorsPerTarget = new LinkedHashMap() { - { - this.put("t1", new Float[][] { new Float[] { 1f, 2f, 3f }, new Float[] { 4f, 5f, 6f } }); - this.put("t2", new Float[][] { new Float[] { .1f, .2f, .3f } }); - } - }; - NearVectorArgument nearVector = NearVectorArgument.builder() - .targets(Targets.builder().targetVectors(new String[] { "t1", "t2" }).build()) - .vectorsPerTarget(vectorsPerTarget).build(); - - String got = nearVector.build(); - - assertEquals( - "nearVector:{vectorPerTarget:{t1:[[1.0,2.0,3.0],[4.0,5.0,6.0]] t2:[0.1,0.2,0.3]} targets:{targetVectors:[\"t1\",\"t1\",\"t2\"]}}", - got); - } - - @Test - public void testBuildWithColBERTVectorsAndTarget() { - NearVectorArgument nearVector = NearVectorArgument.builder() - .targetVectors(new String[] { "colbert" }) - .vector(new Float[][] { { 1f, 2f, 3f }, { 4f, 5f, 6f } }) - .build(); - - String got = nearVector.build(); - - assertEquals( - "nearVector:{vector:[[1.0,2.0,3.0],[4.0,5.0,6.0]] targetVectors:[\"colbert\"]}", - got); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgumentTest.java deleted file mode 100644 index d7671316e..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/NearVideoArgumentTest.java +++ /dev/null @@ -1,148 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import org.junit.Test; - -import java.io.File; -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class NearVideoArgumentTest { - - @Test - public void shouldBuildFromFile() throws IOException { - String nearVideo = NearVideoArgument.builder() - .videoFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\"}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64())); - } - - @Test - public void shouldBuildFromFileWithCertainty() throws IOException { - Float certainty = 0.5f; - - String nearVideo = NearVideoArgument.builder() - .videoFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .certainty(certainty) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" certainty:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), certainty)); - } - - @Test - public void shouldBuildFromFileWithDistance() throws IOException { - Float distance = 0.5f; - - String nearVideo = NearVideoArgument.builder() - .videoFile(NearMediaArgumentHelperTest.exampleMediaFile()) - .distance(distance) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" distance:%s}", - NearMediaArgumentHelperTest.exampleMediaFileAsBase64(), distance)); - } - - @Test - public void shouldBuildFromBase64() { - String videoBase64 = "iVBORw0KGgoAAAANS"; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\"}", videoBase64)); - } - - @Test - public void shouldBuildFromBase64WithHeader() { - String videoBase64 = "data:video/quicktime;base64,iVBORw0KGgoAAAANS"; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .build().build(); - - assertThat(nearVideo).isEqualTo("nearVideo:{video:\"iVBORw0KGgoAAAANS\"}"); - } - - @Test - public void shouldBuildFromBase64WithCertainty() { - String videoBase64 = "iVBORw0KGgoAAAANS"; - Float certainty = 0.5f; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .certainty(certainty) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" certainty:%s}", videoBase64, certainty)); - } - - @Test - public void shouldBuildFromBase64WithDistance() { - String videoBase64 = "iVBORw0KGgoAAAANS"; - Float distance = 0.5f; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .distance(distance) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" distance:%s}", videoBase64, distance)); - } - - @Test - public void shouldBuildFromBase64WithTargetVectors() { - String videoBase64 = "iVBORw0KGgoAAAANS"; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .targetVectors(new String[]{"vector1"}) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" targetVectors:[\"vector1\"]}", videoBase64)); - } - - @Test - public void shouldBuildEmptyDueToBadFile() { - File badFile = new File(""); - - String nearVideo = NearVideoArgument.builder() - .videoFile(badFile) - .build().build(); - - assertThat(nearVideo).isEqualTo("nearVideo:{}"); - } - - @Test - public void shouldBuildEmptyDueToNotSet() { - String nearVideo = NearVideoArgument.builder() - .build().build(); - - assertThat(nearVideo).isEqualTo("nearVideo:{}"); - } - - @Test - public void shouldBuildFromBase64WithTargets() { - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{ "t1", "t2" }) - .combinationMethod(Targets.CombinationMethod.relativeScore) - .weights(weights) - .build(); - - String videoBase64 = "iVBORw0KGgoAAAANS"; - - String nearVideo = NearVideoArgument.builder() - .video(videoBase64) - .targets(targets) - .build().build(); - - assertThat(nearVideo).isEqualTo(String.format("nearVideo:{video:\"%s\" targets:{combinationMethod:relativeScore targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}}", videoBase64)); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentTest.java deleted file mode 100644 index 98aec6e4f..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentTest.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class SortArgumentTest { - - @Test - public void testBuild() { - // given - // when - String arg = SortArgument.builder().path(new String[]{ "property" }).order(SortOrder.asc).build().build(); - // then - assertNotNull(arg); - assertEquals("{path:[\"property\"] order:asc}", arg); - } - - @Test - public void testBuildWithoutOrder() { - // given - // when - String arg = SortArgument.builder().path(new String[]{ "property" }).build().build(); - // then - assertNotNull(arg); - assertEquals("{path:[\"property\"]}", arg); - } - - @Test - public void testBuildWithoutAll() { - // given - // when - String arg = SortArgument.builder().build().build(); - // then - assertNotNull(arg); - // builder will return a faulty nearObject arg in order for Weaviate to error - // so that user will know that something was wrong - assertEquals("{}", arg); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentsTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentsTest.java deleted file mode 100644 index 53d60e83d..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/SortArgumentsTest.java +++ /dev/null @@ -1,46 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import junit.framework.TestCase; -import org.junit.Test; - -public class SortArgumentsTest extends TestCase { - - @Test - public void testBuild() { - // given - SortArgument sort = SortArgument.builder().path(new String[]{"property"}).order(SortOrder.asc).build(); - // when - String res = SortArguments.builder().sort(new SortArgument[]{sort}).build().build(); - // then - assertNotNull(res); - assertEquals("sort:[{path:[\"property\"] order:asc}]", res); - } - - @Test - public void testBuildWithMoreThenOneSortArgument() { - // given - SortArgument sort1 = SortArgument.builder().path(new String[]{"property"}).order(SortOrder.asc).build(); - SortArgument sort2 = SortArgument.builder().path(new String[]{"other"}).order(SortOrder.desc).build(); - SortArgument sort3 = SortArgument.builder().path(new String[]{"no-sort-order"}).build(); - // when - String res = SortArguments.builder().sort(new SortArgument[]{sort1, sort2, sort3}).build().build(); - // then - assertNotNull(res); - assertEquals("sort:[{path:[\"property\"] order:asc},{path:[\"other\"] order:desc},{path:[\"no-sort-order\"]}]", res); - } - - @Test - public void testBuildWithoutAll() { - // given - // when - String res1 = SortArguments.builder().sort(null).build().build(); - String res2 = SortArguments.builder().sort(new SortArgument[]{SortArgument.builder().build()}).build().build(); - // then - // builder will return a faulty sort arg in order for Weaviate to error - // so that user will know that something was wrong - assertNotNull(res1); - assertEquals("sort:[]", res1); - assertNotNull(res2); - assertEquals("sort:[{}]", res2); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/TargetsTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/TargetsTest.java deleted file mode 100644 index 14edff4f0..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/TargetsTest.java +++ /dev/null @@ -1,59 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import java.util.LinkedHashMap; -import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import org.junit.Test; - -public class TargetsTest { - - @Test - public void testBuild() { - // given - Targets targets = Targets.builder() - .targetVectors(new String[]{"t1", "t2"}) - .combinationMethod(Targets.CombinationMethod.average) - .build(); - // when - String targetsStr = targets.build(); - // then - assertNotNull(targetsStr); - assertEquals("targets:{combinationMethod:average targetVectors:[\"t1\",\"t2\"]}", targetsStr); - } - - @Test - public void testBuildWithWeights() { - // given - LinkedHashMap weights = new LinkedHashMap<>(); - weights.put("t1", 0.8f); - weights.put("t2", 0.2f); - Targets targets = Targets.builder() - .targetVectors(new String[]{"t1", "t2"}) - .combinationMethod(Targets.CombinationMethod.manualWeights) - .weights(weights) - .build(); - // when - String targetsStr = targets.build(); - // then - assertNotNull(targetsStr); - assertEquals("targets:{combinationMethod:manualWeights targetVectors:[\"t1\",\"t2\"] weights:{t1:0.8 t2:0.2}}", targetsStr); - } - - @Test - public void testMultipleWeightsPerTargetVector() { - Map weights = new LinkedHashMap() { - { - this.put("t1", new Float[]{.8f, .34f}); - this.put("t2", new Float[]{.2f}); - } - }; - Targets targets = - Targets.builder().targetVectors(new String[]{"t1", "t2"}).combinationMethod(Targets.CombinationMethod.relativeScore).weightsMulti(weights).build(); - - String got = targets.build(); - - assertNotNull(got); - assertEquals("targets:{combinationMethod:relativeScore targetVectors:[\"t1\",\"t2\"] weights:{t1:[0.8,0.34] t2:0.2}}", got); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/argument/WhereArgumentTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/argument/WhereArgumentTest.java deleted file mode 100644 index 850dd1235..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/argument/WhereArgumentTest.java +++ /dev/null @@ -1,447 +0,0 @@ -package io.weaviate.client.v1.graphql.query.argument; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.time.ZoneOffset; -import java.util.Calendar; -import java.util.TimeZone; - -import org.junit.Test; -import org.junit.runner.RunWith; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; - -@RunWith(JParamsTestRunner.class) -public class WhereArgumentTest { - - @Test - public void testValueText() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueText("txt") - .operator(Operator.And) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueText:\"txt\" operator:And}"); - } - - @Test - public void testDeprecatedValueString() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueString("txt") - .operator(Operator.Equal) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueString:\"txt\" operator:Equal}"); - } - - @Test - public void testValueInt() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueInt(11) - .operator(Operator.Or) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueInt:11 operator:Or}"); - } - - @Test - public void testValueBoolean() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueBoolean(true) - .operator(Operator.GreaterThan) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueBoolean:true operator:GreaterThan}"); - } - - @Test - public void testValueNumber() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueNumber(22.1) - .operator(Operator.GreaterThanEqual) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueNumber:22.1 operator:GreaterThanEqual}"); - } - - @Test - public void testValueGeoCoordinates() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueGeoRange(WhereFilter.GeoRange.builder() - .geoCoordinates(WhereFilter.GeoCoordinates.builder() - .latitude(50.51f) - .longitude(0.11f) - .build()) - .distance(WhereFilter.GeoDistance.builder() - .max(3000f) - .build()) - .build()) - .operator(Operator.WithinGeoRange).path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo( - "where:{path:[\"add\"] valueGeoRange:{geoCoordinates:{latitude:50.51,longitude:0.11},distance:{max:3000.0}} operator:WithinGeoRange}"); - } - - @Test - public void testValueDate() { - TimeZone.setDefault(TimeZone.getTimeZone("UTC")); - Calendar cal = Calendar.getInstance(); - cal.set(2023, Calendar.MARCH, 15, 17, 1, 2); - - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueDate(cal.getTime()) - .operator(Operator.Like) - .path(new String[] { "add" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo("where:{path:[\"add\"] valueDate:\"2023-03-15T17:01:02+00:00\" operator:Like}"); - } - - @Test - public void testOperands() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .operands(new WhereFilter[] { - WhereFilter.builder() - .valueInt(10) - .path(new String[] { "wordCount" }) - .operator(Operator.LessThanEqual) - .build(), - WhereFilter.builder() - .valueText("word") - .path(new String[] { "word" }) - .operator(Operator.LessThan) - .build(), - }) - .operator(Operator.And) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo( - "where:{operator:And operands:[{path:[\"wordCount\"] valueInt:10 operator:LessThanEqual},{path:[\"word\"] valueText:\"word\" operator:LessThan}]}"); - } - - @Test - public void testMultiplePathParams() { - TimeZone.setDefault(TimeZone.getTimeZone("UTC")); - Calendar cal = Calendar.getInstance(); - cal.set(2023, Calendar.MARCH, 15, 17, 1, 2); - - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .valueDate(cal.getTime()) - .operator(Operator.Not) - .path(new String[] { "p1", "p2", "p3" }) - .build()) - .build(); - - String str = where.build(); - - assertThat(str) - .isEqualTo("where:{path:[\"p1\",\"p2\",\"p3\"] valueDate:\"2023-03-15T17:01:02+00:00\" operator:Not}"); - } - - @Test - public void testOperandsWithMultiplePathParams() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .operands(new WhereFilter[] { - WhereFilter.builder() - .valueInt(10) - .operator(Operator.LessThanEqual) - .path(new String[] { "wordCount" }) - .build(), - WhereFilter.builder() - .valueText("word") - .operator(Operator.LessThan) - .path(new String[] { "w1", "w2", "w3" }) - .build(), - }) - .operator(Operator.NotEqual) - .build()) - .build(); - - String str = where.build(); - - assertThat(str).isEqualTo( - "where:{operator:NotEqual operands:[{path:[\"wordCount\"] valueInt:10 operator:LessThanEqual},{path:[\"w1\",\"w2\",\"w3\"] valueText:\"word\" operator:LessThan}]}"); - } - - @Test - public void testWithoutAll() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder().build()) - .build(); - - String str = where.build(); - - // builder will return a faulty where arg in order for Weaviate to error - // so that user will know that something was wrong - assertThat(str).isEqualTo("where:{}"); - } - - @Test - @DataMethod(source = WhereArgumentTest.class, method = "provideForContains") - public void shouldCreateWhereForContains(WhereFilter filter, String expectedWhere) { - String where = WhereArgument.builder().filter(filter).build().build(); - assertThat(where).isEqualTo(expectedWhere); - } - - public static Object[][] provideForContains() { - TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC)); - Calendar cal1 = Calendar.getInstance(); - cal1.set(2023, Calendar.JANUARY, 15, 17, 1, 2); - Calendar cal2 = Calendar.getInstance(); - cal2.set(2023, Calendar.FEBRUARY, 15, 17, 1, 2); - Calendar cal3 = Calendar.getInstance(); - cal3.set(2023, Calendar.MARCH, 15, 17, 1, 2); - - return new Object[][] { - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueBoolean(true) - .build(), - "where:{path:[\"some\",\"path\"] valueBoolean:[true] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueBoolean(true, false) - .build(), - "where:{path:[\"another_path\"] valueBoolean:[true,false] operator:ContainsAny}", - }, - - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueInt(1) - .build(), - "where:{path:[\"some\",\"path\"] valueInt:[1] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueInt(2, 3) - .build(), - "where:{path:[\"another_path\"] valueInt:[2,3] operator:ContainsAny}", - }, - - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueNumber(1.1) - .build(), - "where:{path:[\"some\",\"path\"] valueNumber:[1.1] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueNumber(2.2, 3.3) - .build(), - "where:{path:[\"another_path\"] valueNumber:[2.2,3.3] operator:ContainsAny}", - }, - - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueString("string") - .build(), - "where:{path:[\"some\",\"path\"] valueString:[\"string\"] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueString("string1", "string2") - .build(), - "where:{path:[\"another_path\"] valueString:[\"string1\",\"string2\"] operator:ContainsAny}", - }, - - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueText("text") - .build(), - "where:{path:[\"some\",\"path\"] valueText:[\"text\"] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueText("text1", "text2") - .build(), - "where:{path:[\"another_path\"] valueText:[\"text1\",\"text2\"] operator:ContainsAny}", - }, - - { - WhereFilter.builder().path("some", "path") - .operator(Operator.ContainsAll) - .valueDate(cal1.getTime()) - .build(), - "where:{path:[\"some\",\"path\"] valueDate:[\"2023-01-15T17:01:02+00:00\"] operator:ContainsAll}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsAny) - .valueDate(cal2.getTime(), cal3.getTime()) - .build(), - "where:{path:[\"another_path\"] valueDate:[\"2023-02-15T17:01:02+00:00\",\"2023-03-15T17:01:02+00:00\"] operator:ContainsAny}", - }, - { - WhereFilter.builder().path("another_path") - .operator(Operator.ContainsNone) - .valueDate(cal2.getTime(), cal3.getTime()) - .build(), - "where:{path:[\"another_path\"] valueDate:[\"2023-02-15T17:01:02+00:00\",\"2023-03-15T17:01:02+00:00\"] operator:ContainsNone}", - }, - }; - } - - @Test - @DataMethod(source = WhereArgumentTest.class, method = "provideForSingleValOrArray") - public void shouldCreateWhereWithSingleValOrArray(WhereFilter filter, String expectedWhere) { - String where = WhereArgument.builder().filter(filter).build().build(); - assertThat(where).isEqualTo(expectedWhere); - } - - public static Object[][] provideForSingleValOrArray() { - TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC)); - Calendar cal1 = Calendar.getInstance(); - cal1.set(2023, Calendar.JANUARY, 15, 17, 1, 2); - Calendar cal2 = Calendar.getInstance(); - cal2.set(2023, Calendar.FEBRUARY, 15, 17, 1, 2); - Calendar cal3 = Calendar.getInstance(); - cal3.set(2023, Calendar.MARCH, 15, 17, 1, 2); - - return new Object[][] { - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueBoolean(true) - .build(), - "where:{path:[\"some\",\"path\"] valueBoolean:true operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueBoolean(true, false) - .build(), - "where:{path:[\"another_path\"] valueBoolean:[true,false] operator:Equal}", - }, - - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueInt(1) - .build(), - "where:{path:[\"some\",\"path\"] valueInt:1 operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueInt(2, 3) - .build(), - "where:{path:[\"another_path\"] valueInt:[2,3] operator:Equal}", - }, - - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueNumber(1.1) - .build(), - "where:{path:[\"some\",\"path\"] valueNumber:1.1 operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueNumber(2.2, 3.3) - .build(), - "where:{path:[\"another_path\"] valueNumber:[2.2,3.3] operator:Equal}", - }, - - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueString("string") - .build(), - "where:{path:[\"some\",\"path\"] valueString:\"string\" operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueString("string1", "string2") - .build(), - "where:{path:[\"another_path\"] valueString:[\"string1\",\"string2\"] operator:Equal}", - }, - - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueText("text") - .build(), - "where:{path:[\"some\",\"path\"] valueText:\"text\" operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueText("text1", "text2") - .build(), - "where:{path:[\"another_path\"] valueText:[\"text1\",\"text2\"] operator:Equal}", - }, - - new Object[] { - WhereFilter.builder().path("some", "path") - .operator(Operator.Equal) - .valueDate(cal1.getTime()) - .build(), - "where:{path:[\"some\",\"path\"] valueDate:\"2023-01-15T17:01:02+00:00\" operator:Equal}", - }, - new Object[] { - WhereFilter.builder().path("another_path") - .operator(Operator.Equal) - .valueDate(cal2.getTime(), cal3.getTime()) - .build(), - "where:{path:[\"another_path\"] valueDate:[\"2023-02-15T17:01:02+00:00\",\"2023-03-15T17:01:02+00:00\"] operator:Equal}", - }, - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilderTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilderTest.java deleted file mode 100644 index 0bd9bd8ea..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/builder/AggregateBuilderTest.java +++ /dev/null @@ -1,461 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class AggregateBuilderTest { - - @Test - public void testBuildSimpleAggregate() { - // given - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - // when - String query = AggregateBuilder.builder().className("Pizza").fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Aggregate{Pizza{meta{count}}}}", query); - } - - @Test - public void testBuildAggregateWithGroupBy() { - // given - Field groupBy = Field.builder() - .name("groupedBy") - .fields(new Field[]{Field.builder().name("value").build()}) - .build(); - Field name = Field.builder() - .name("name") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{groupBy, name}).build(); - // when - String query = AggregateBuilder.builder().className("Pizza").fields(fields).groupByClausePropertyName("name").build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Aggregate{Pizza(groupBy:\"name\"){groupedBy{value} name{count}}}}", query); - } - - @Test - public void testBuildAggregateWithGroupByAndLimit() { - // given - Field groupBy = Field.builder() - .name("groupedBy") - .fields(new Field[]{Field.builder().name("value").build()}) - .build(); - Field name = Field.builder() - .name("name") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{groupBy, name}).build(); - // when - String query = AggregateBuilder.builder().className("Pizza").fields(fields). - groupByClausePropertyName("name").limit(10) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Aggregate{Pizza(groupBy:\"name\" limit:10){groupedBy{value} name{count}}}}", query); - } - - @Test - public void testBuildAggregateWithWhere() { - // given - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - // when - String query = AggregateBuilder.builder().className("Pizza").fields(fields).withWhereFilter(where).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Aggregate{Pizza(where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){meta{count}}}}", query); - } - - @Test - public void testBuildAggregateWithWhereAndGroupedBy() { - // given - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - // when - String query = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .groupByClausePropertyName("name") - .withWhereFilter(where) - .build() - .buildQuery(); - // then - assertNotNull(query); - assertEquals("{Aggregate{Pizza(groupBy:\"name\" where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){meta{count}}}}", query); - } - - @Test - public void testBuildAggregateWithNearVector() { - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - - // given (certainty) - NearVectorArgument nearVectorWithCert = NearVectorArgument.builder().vector(new Float[]{0f, 1f, 0.8f}).certainty(0.8f).build(); - - // when (certainty) - String queryWithCert = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearVectorFilter(nearVectorWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Aggregate{Pizza(nearVector:{vector:[0.0,1.0,0.8] certainty:0.8}){meta{count}}}}", queryWithCert); - - // given (distance) - NearVectorArgument nearVectorWithDist = NearVectorArgument.builder().vector(new Float[]{0f, 1f, 0.8f}).distance(0.8f).build(); - - // when (distance) - String queryWithDist = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearVectorFilter(nearVectorWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Aggregate{Pizza(nearVector:{vector:[0.0,1.0,0.8] distance:0.8}){meta{count}}}}", queryWithDist); - } - - @Test - public void testBuildAggregateWithNearObject() { - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - - // given (certainty) - NearObjectArgument nearObjectWithCert = NearObjectArgument.builder().id("some-uuid").certainty(0.8f).build(); - // when (certainty) - String queryWithCert = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearObjectFilter(nearObjectWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Aggregate{Pizza(nearObject:{id:\"some-uuid\" certainty:0.8}){meta{count}}}}", queryWithCert); - - // given (distance) - NearObjectArgument nearObjectWithDist = NearObjectArgument.builder().id("some-uuid").distance(0.8f).build(); - // when (distance) - String queryWithDist = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearObjectFilter(nearObjectWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Aggregate{Pizza(nearObject:{id:\"some-uuid\" distance:0.8}){meta{count}}}}", queryWithDist); - } - - @Test - public void testBuildAggregateWithAsk() { - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - - // given (certainty) - AskArgument askWithCert = AskArgument.builder().question("question?").rerank(true).certainty(0.8f).build(); - // when (certainty) - String queryWithCert = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withAskArgument(askWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Aggregate{Pizza(ask:{question:\"question?\" certainty:0.8 rerank:true}){meta{count}}}}", queryWithCert); - - // given (distance) - AskArgument askWithDist = AskArgument.builder().question("question?").rerank(true).distance(0.8f).build(); - // when (distance) - String queryWithDist = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withAskArgument(askWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Aggregate{Pizza(ask:{question:\"question?\" distance:0.8 rerank:true}){meta{count}}}}", queryWithDist); - } - - @Test - public void testBuildAggregateWithNearImage() { - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - - // given (certainty) - NearImageArgument nearImageWithCert = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").certainty(0.8f).build(); - // when (certainty) - String queryWithCert = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearImageFilter(nearImageWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Aggregate{Pizza(nearImage:{image:\"iVBORw0KGgoAAAANS\" certainty:0.8}){meta{count}}}}", queryWithCert); - - // given (certainty) - NearImageArgument nearImageWithDist = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").distance(0.8f).build(); - // when (certainty) - String queryWithDist = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearImageFilter(nearImageWithDist).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithDist); - assertEquals("{Aggregate{Pizza(nearImage:{image:\"iVBORw0KGgoAAAANS\" distance:0.8}){meta{count}}}}", queryWithDist); - } - - @Test - public void testBuildAggregateWithObjectLimit() { - Field meta = Field.builder() - .name("meta") - .fields(new Field[]{Field.builder().name("count").build()}) - .build(); - Fields fields = Fields.builder().fields(new Field[]{meta}).build(); - - // given (certainty) - NearImageArgument nearImageWithCert = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").certainty(0.8f).build(); - // when (certainty) - String queryWithCert = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearImageFilter(nearImageWithCert) - .objectLimit(100).build() - .buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Aggregate{Pizza(nearImage:{image:\"iVBORw0KGgoAAAANS\" certainty:0.8} objectLimit:100){meta{count}}}}", queryWithCert); - - // given (distance) - NearImageArgument nearImageWithDist = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").distance(0.8f).build(); - // when (distance) - String queryWithDist = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearImageFilter(nearImageWithDist) - .objectLimit(100).build() - .buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Aggregate{Pizza(nearImage:{image:\"iVBORw0KGgoAAAANS\" distance:0.8} objectLimit:100){meta{count}}}}", queryWithDist); - } - - @Test - public void shouldSupportDeprecatedWhereFilter() { - WhereFilter where = WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .groupByClausePropertyName("name") - .withWhereFilter(where) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{Pizza(groupBy:\"name\" where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithTenant() { - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .tenant("TenantNo1") - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{Pizza(tenant:\"TenantNo1\"){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithTenantAndWhere() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("Pizza") - .fields(fields) - .tenant("TenantNo1") - .withWhereFilter(where) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{Pizza(tenant:\"TenantNo1\" where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithNearAudio() { - NearAudioArgument nearAudio = NearAudioArgument.builder() - .audio("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - - String query = AggregateBuilder.builder() - .className("PizzaAudio") - .fields(fields) - .withNearAudioFilter(nearAudio) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{PizzaAudio(nearAudio:{audio:\"iVBORw0KGgoAAAANS\" distance:0.1}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithNearVideo() { - NearVideoArgument nearVideo = NearVideoArgument.builder() - .video("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("PizzaVideo") - .fields(fields) - .withNearVideoFilter(nearVideo) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{PizzaVideo(nearVideo:{video:\"iVBORw0KGgoAAAANS\" distance:0.1}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithNearDepth() { - NearDepthArgument nearDepth = NearDepthArgument.builder() - .depth("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("PizzaDepth") - .fields(fields) - .withNearDepthFilter(nearDepth) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{PizzaDepth(nearDepth:{depth:\"iVBORw0KGgoAAAANS\" distance:0.1}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithNearThermal() { - NearThermalArgument nearThermal = NearThermalArgument.builder() - .thermal("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("PizzaThermal") - .fields(fields) - .withNearThermalFilter(nearThermal) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{PizzaThermal(nearThermal:{thermal:\"iVBORw0KGgoAAAANS\" distance:0.1}){meta{count}}}}"); - } - - @Test - public void shouldBuildAggregateWithNearImu() { - NearImuArgument nearImu = NearImuArgument.builder() - .imu("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(Field.builder().name("count").build()) - .build(); - Fields fields = Fields.builder().fields(meta).build(); - - String query = AggregateBuilder.builder() - .className("PizzaImu") - .fields(fields) - .withNearImuFilter(nearImu) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Aggregate{PizzaImu(nearIMU:{imu:\"iVBORw0KGgoAAAANS\" distance:0.1}){meta{count}}}}"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilderTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilderTest.java deleted file mode 100644 index 5e6663095..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/builder/ExploreBuilderTest.java +++ /dev/null @@ -1,356 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import io.weaviate.client.v1.graphql.model.ExploreFields; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class ExploreBuilderTest { - - @Test - public void testBuildQuery() { - // given - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{"a1", "b2"}).force(0.1f).build(); - - // when (certainty) - NearTextArgument nearTextWithCert = NearTextArgument.builder() - .concepts(new String[]{"a", "b"}).certainty(0.8f).moveTo(moveTo).build(); - String queryWithCert = ExploreBuilder.builder().withNearText(nearTextWithCert).fields(fields).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Explore(nearText:{concepts:[\"a\",\"b\"] certainty:0.8 moveTo:{concepts:[\"a1\",\"b2\"] force:0.1}}){certainty,distance," + - "beacon,className}}", queryWithCert); - - // when (distance) - NearTextArgument nearTextWithDist = NearTextArgument.builder() - .concepts(new String[]{"a", "b"}).distance(0.8f).moveTo(moveTo).build(); - String queryWithDist = ExploreBuilder.builder().withNearText(nearTextWithDist).fields(fields).build().buildQuery(); - // then (distance) - assertNotNull(queryWithCert); - assertEquals("{Explore(nearText:{concepts:[\"a\",\"b\"] distance:0.8 moveTo:{concepts:[\"a1\",\"b2\"] force:0.1}}){certainty,distance," + - "beacon,className}}", queryWithDist); - } - - @Test - public void testBuildSimpleExplore() { - // given - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.BEACON, ExploreFields.DISTANCE}; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"Cheese", "pineapple"}).build(); - // when - String query = ExploreBuilder.builder().withNearText(nearText).fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Explore(nearText:{concepts:[\"Cheese\",\"pineapple\"]}){certainty,beacon,distance}}", query); - } - - @Test - public void testBuildExploreWithLimitAndCertainty() { - // given - ExploreFields[] fields = new ExploreFields[]{ExploreFields.BEACON}; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"Cheese"}).certainty(0.71f).build(); - // when - String query = ExploreBuilder.builder().withNearText(nearText).fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Explore(nearText:{concepts:[\"Cheese\"] certainty:0.71}){beacon}}", query); - } - - @Test - public void testBuildExploreWithLimitAndDistance() { - // given - ExploreFields[] fields = new ExploreFields[]{ExploreFields.BEACON}; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"Cheese"}).distance(0.71f).build(); - // when - String query = ExploreBuilder.builder().withNearText(nearText).fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Explore(nearText:{concepts:[\"Cheese\"] distance:0.71}){beacon}}", query); - } - - @Test - public void testBuildExploreWithMove() { - // given - String[] concepts = new String[]{"Cheese"}; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{"pizza", "pineapple"}).force(0.2f).build(); - NearTextMoveParameters moveAwayFrom = NearTextMoveParameters.builder() - .concepts(new String[]{"fish"}).force(0.1f).build(); - ExploreFields[] fields = new ExploreFields[]{ExploreFields.BEACON}; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).moveTo(moveTo).moveAwayFrom(moveAwayFrom) - .build(); - // when - String query = ExploreBuilder.builder().withNearText(nearText).fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Explore(nearText:{concepts:[\"Cheese\"] " + - "moveTo:{concepts:[\"pizza\",\"pineapple\"] force:0.2} " + - "moveAwayFrom:{concepts:[\"fish\"] force:0.1}}){beacon}}", query); - } - - @Test - public void testBuildExploreWithAllParams() { - // given - String[] concepts = new String[]{"New Yorker"}; - Float certainty = 0.95f; - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .concepts(new String[]{"publisher", "articles"}).force(0.5f) - .build(); - NearTextMoveParameters moveAwayFrom = NearTextMoveParameters.builder() - .concepts(new String[]{"fashion", "shop"}).force(0.2f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - NearTextArgument nearText = NearTextArgument.builder() - .concepts(concepts).moveTo(moveTo).moveAwayFrom(moveAwayFrom) - .build(); - // when - String query = ExploreBuilder.builder().withNearText(nearText).fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Explore(nearText:{concepts:[\"New Yorker\"] moveTo:{concepts:[\"publisher\",\"articles\"] force:0.5} moveAwayFrom:{concepts:" + - "[\"fashion\",\"shop\"] force:0.2}}){certainty,distance,beacon,className}}", query); - } - - @Test - public void testBuildExploreWithNearVector() { - // given (certainty) - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, - ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - NearVectorArgument nearVectorWithCert = NearVectorArgument.builder() - .vector(new Float[]{0f, 1f, 0.8f}).certainty(0.8f).build(); - - // when (certainty) - String queryWithCert = ExploreBuilder.builder() - .fields(fields) - .withNearVectorFilter(nearVectorWithCert).build().buildQuery(); - - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Explore(nearVector:{vector:[0.0,1.0,0.8] certainty:0.8})" + - "{certainty,distance,beacon,className}}", queryWithCert); - - // given (distance) - NearVectorArgument nearVectorWithDist = NearVectorArgument.builder() - .vector(new Float[]{0f, 1f, 0.8f}).distance(0.8f).build(); - - // when (distance) - String queryWithDist = ExploreBuilder.builder() - .fields(fields) - .withNearVectorFilter(nearVectorWithDist).build().buildQuery(); - - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Explore(nearVector:{vector:[0.0,1.0,0.8] distance:0.8})" + - "{certainty,distance,beacon,className}}", queryWithDist); - } - - @Test - public void testBuildExploreWithNearObject() { - // given (certainty) - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, - ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - NearObjectArgument nearObjectWithCert = NearObjectArgument.builder().id("some-uuid").certainty(0.8f).build(); - // when (certainty) - String queryWithCert = ExploreBuilder.builder() - .fields(fields) - .withNearObjectFilter(nearObjectWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Explore(nearObject:{id:\"some-uuid\" certainty:0.8}){certainty,distance," + - "beacon,className}}", queryWithCert); - - // given (distance) - NearObjectArgument nearObjectWithDist = NearObjectArgument.builder().id("some-uuid").distance(0.8f).build(); - // when (distance) - String queryWithDist = ExploreBuilder.builder() - .fields(fields) - .withNearObjectFilter(nearObjectWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Explore(nearObject:{id:\"some-uuid\" distance:0.8}){certainty,distance," + - "beacon,className}}", - queryWithDist); - } - - @Test - public void testBuildExploreWithAsk() { - // given (certainty) - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, - ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - AskArgument askWithCert = AskArgument.builder().question("question?").rerank(true).certainty(0.8f).build(); - // when (certainty) - String queryWithCert = ExploreBuilder.builder() - .fields(fields) - .withAskArgument(askWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Explore(ask:{question:\"question?\" certainty:0.8 rerank:true}){certainty,distance," + - "beacon,className}}", queryWithCert); - - // given (distance) - AskArgument askWithDist = AskArgument.builder().question("question?").rerank(true).distance(0.8f).build(); - // when (distance) - String queryWithDist = ExploreBuilder.builder() - .fields(fields) - .withAskArgument(askWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Explore(ask:{question:\"question?\" distance:0.8 rerank:true}){certainty,distance," + - "beacon,className}}", queryWithDist); - } - - @Test - public void testBuildExploreWithNearImage() { - // given (certainty) - ExploreFields[] fields = new ExploreFields[]{ExploreFields.CERTAINTY, ExploreFields.DISTANCE, - ExploreFields.BEACON, ExploreFields.CLASS_NAME}; - NearImageArgument nearImageWithCert = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").certainty(0.8f).build(); - // when (certainty) - String queryWithCert = ExploreBuilder.builder() - .fields(fields) - .withNearImageFilter(nearImageWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Explore(nearImage:{image:\"iVBORw0KGgoAAAANS\" certainty:0.8}){certainty,distance," + - "beacon,className}}", queryWithCert); - - // given (distance) - NearImageArgument nearImageWithDist = NearImageArgument.builder().image("iVBORw0KGgoAAAANS").distance(0.8f).build(); - // when (distance) - String queryWithDist = ExploreBuilder.builder() - .fields(fields) - .withNearImageFilter(nearImageWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Explore(nearImage:{image:\"iVBORw0KGgoAAAANS\" distance:0.8}){certainty,distance," + - "beacon,className}}", queryWithDist); - } - - @Test - public void shouldBuildExploreWithNearAudio() { - NearAudioArgument nearAudio = NearAudioArgument.builder() - .audio("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ - ExploreFields.CERTAINTY, - ExploreFields.DISTANCE, - ExploreFields.BEACON, - ExploreFields.CLASS_NAME, - }; - - String query = ExploreBuilder.builder() - .fields(fields) - .withNearAudioFilter(nearAudio) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Explore(nearAudio:{audio:\"iVBORw0KGgoAAAANS\" distance:0.1})" + - "{certainty,distance,beacon,className}}"); - } - - @Test - public void shouldBuildExploreWithNearVideo() { - NearVideoArgument nearVideo = NearVideoArgument.builder() - .video("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ - ExploreFields.CERTAINTY, - ExploreFields.DISTANCE, - ExploreFields.BEACON, - ExploreFields.CLASS_NAME, - }; - - String query = ExploreBuilder.builder() - .fields(fields) - .withNearVideoFilter(nearVideo) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Explore(nearVideo:{video:\"iVBORw0KGgoAAAANS\" distance:0.1})" + - "{certainty,distance,beacon,className}}"); - } - - @Test - public void shouldBuildExploreWithNearDepth() { - NearDepthArgument nearDepth = NearDepthArgument.builder() - .depth("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ - ExploreFields.CERTAINTY, - ExploreFields.DISTANCE, - ExploreFields.BEACON, - ExploreFields.CLASS_NAME, - }; - - String query = ExploreBuilder.builder() - .fields(fields) - .withNearDepthFilter(nearDepth) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Explore(nearDepth:{depth:\"iVBORw0KGgoAAAANS\" distance:0.1})" + - "{certainty,distance,beacon,className}}"); - } - - @Test - public void shouldBuildExploreWithNearThermal() { - NearThermalArgument nearThermal = NearThermalArgument.builder() - .thermal("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ - ExploreFields.CERTAINTY, - ExploreFields.DISTANCE, - ExploreFields.BEACON, - ExploreFields.CLASS_NAME, - }; - - String query = ExploreBuilder.builder() - .fields(fields) - .withNearThermalFilter(nearThermal) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Explore(nearThermal:{thermal:\"iVBORw0KGgoAAAANS\" distance:0.1})" + - "{certainty,distance,beacon,className}}"); - } - - @Test - public void shouldBuildExploreWithNearImu() { - NearImuArgument nearImu = NearImuArgument.builder() - .imu("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - ExploreFields[] fields = new ExploreFields[]{ - ExploreFields.CERTAINTY, - ExploreFields.DISTANCE, - ExploreFields.BEACON, - ExploreFields.CLASS_NAME, - }; - - String query = ExploreBuilder.builder() - .fields(fields) - .withNearImuFilter(nearImu) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Explore(nearIMU:{imu:\"iVBORw0KGgoAAAANS\" distance:0.1})" + - "{certainty,distance,beacon,className}}"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/builder/GetBuilderTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/builder/GetBuilderTest.java deleted file mode 100644 index 4b710694a..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/builder/GetBuilderTest.java +++ /dev/null @@ -1,784 +0,0 @@ -package io.weaviate.client.v1.graphql.query.builder; - -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.query.argument.AskArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupType; -import io.weaviate.client.v1.graphql.query.argument.NearAudioArgument; -import io.weaviate.client.v1.graphql.query.argument.NearDepthArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImageArgument; -import io.weaviate.client.v1.graphql.query.argument.NearImuArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearThermalArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVideoArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArguments; -import io.weaviate.client.v1.graphql.query.argument.SortOrder; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder; -import org.junit.Test; - -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStreamReader; -import java.util.stream.Collectors; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -public class GetBuilderTest { - - @Test - public void testBuildSimpleGet() { - // given - Field name = Field.builder().name("name").build(); - // when - String query = GetBuilder.builder().className("Pizza").fields(Fields.builder().fields(new Field[]{name}).build()).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza{name}}}", query); - } - - @Test - public void testBuildGetMultipleFields() { - // given - Field name = Field.builder().name("name").build(); - Field description = Field.builder().name("description").build(); - Fields fields = Fields.builder().fields(new Field[]{name, description}).build(); - // when - String query = GetBuilder.builder().className("Pizza").fields(fields).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza{name description}}}", query); - } - - @Test - public void testBuildGetWhereFilter() { - // given - Field name = Field.builder().name("name").build(); - Fields fields = Fields.builder().fields(new Field[]{name}).build(); - WhereArgument where1 = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - WhereArgument where2 = WhereArgument.builder() - .filter(WhereFilter.builder() - .operands(new WhereFilter[]{ - WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build(), - WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Doener") - .build(), - }) - .operator(Operator.Or) - .build()) - .build(); - // when - String query1 = GetBuilder.builder().className("Pizza").fields(fields).withWhereFilter(where1).build().buildQuery(); - String query2 = GetBuilder.builder().className("Pizza").fields(fields).withWhereFilter(where2).build().buildQuery(); - // then - assertNotNull(query1); - assertEquals("{Get{Pizza(where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){name}}}", query1); - assertNotNull(query2); - assertEquals("{Get{Pizza" + - "(where:{operator:Or operands:[{path:[\"name\"] valueText:\"Hawaii\" operator:Equal},{path:[\"name\"] valueText:\"Doener\" operator:Equal}]})" + - "{name}}}", query2); - } - - @Test - public void testBuildGetWithLimit() { - // given - Field name = Field.builder().name("name").build(); - Fields fields = Fields.builder().fields(new Field[]{name}).build(); - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .limit(2) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(limit:2){name}}}", query); - } - - @Test - public void testBuildGetWithLimitAndOffset() { - // given - Field name = Field.builder().name("name").build(); - Fields fields = Fields.builder().fields(new Field[]{name}).build(); - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .offset(0) - .limit(2) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(limit:2 offset:0){name}}}", query); - } - - @Test - public void testBuildGetWithLimitAndAfter() { - // given - Field name = Field.builder().name("name").build(); - Fields fields = Fields.builder().fields(new Field[]{name}).build(); - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .after("00000000-0000-0000-0000-000000000000") - .limit(2) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(limit:2 after:\"00000000-0000-0000-0000-000000000000\"){name}}}", query); - } - - @Test - public void testBuildGetWithNearText() { - // given - Field name = Field.builder().name("name").build(); - NearTextArgument nearText = NearTextArgument.builder().concepts(new String[]{"good"}).build(); - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(Fields.builder().fields(new Field[]{name}).build()) - .withNearTextFilter(nearText).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(nearText:{concepts:[\"good\"]}){name}}}", query); - } - - @Test - public void testBuildGetWithNearVector() { - Field name = Field.builder().name("name").build(); - - // given (certainty) - NearVectorArgument nearVectorWithCert = NearVectorArgument.builder() - .vector(new Float[]{0f, 1f, 0.8f}).certainty(0.8f).build(); - // when (certainty) - String queryWithCert = GetBuilder.builder().className("Pizza") - .fields(Fields.builder().fields(new Field[]{name}).build()) - .withNearVectorFilter(nearVectorWithCert).build().buildQuery(); - // then (certainty) - assertNotNull(queryWithCert); - assertEquals("{Get{Pizza(nearVector:{vector:[0.0,1.0,0.8] certainty:0.8}){name}}}", queryWithCert); - - // given (distance) - NearVectorArgument nearVectorWithDist = NearVectorArgument.builder() - .vector(new Float[]{0f, 1f, 0.8f}).distance(0.8f).build(); - // when (distance) - String queryWithDist = GetBuilder.builder().className("Pizza") - .fields(Fields.builder().fields(new Field[]{name}).build()) - .withNearVectorFilter(nearVectorWithDist).build().buildQuery(); - // then (distance) - assertNotNull(queryWithDist); - assertEquals("{Get{Pizza(nearVector:{vector:[0.0,1.0,0.8] distance:0.8}){name}}}", queryWithDist); - } - - @Test - public void testBuildGetWithGroupFilter() { - // given - Field name = Field.builder().name("name").build(); - GroupArgument group = GroupArgument.builder().type(GroupType.closest).force(0.4f).build(); - // when - String query = GetBuilder.builder().className("Pizza") - .fields(Fields.builder().fields(new Field[]{name}).build()) - .withGroupArgument(group).build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(group:{type:closest force:0.4}){name}}}", query); - } - - @Test - public void testBuildGetWithMultipleFilter() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"good"}) - .build(); - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Integer limit = 2; - // when - String query = GetBuilder.builder() - .className("Pizza").fields(fields).withNearTextFilter(nearText).withWhereFilter(where).limit(limit) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal} nearText:{concepts:[\"good\"]} limit:2){name}}}", query); - } - - @Test - public void testBuildGetWithNearTextWithConcepts() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"good"}) - .build(); - // when - String query = GetBuilder.builder() - .className("Pizza").fields(fields).withNearTextFilter(nearText) - .build().buildQuery(); - // then - assertNotNull(query); - assertEquals("{Get{Pizza(nearText:{concepts:[\"good\"]}){name}}}", query); - } - - @Test - public void testBuildGetWithAskAndCertainty() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - AskArgument ask1 = AskArgument.builder() - .question("Who are you?") - .build(); - AskArgument ask2 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .build(); - AskArgument ask3 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .certainty(0.1f) - .build(); - AskArgument ask4 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .certainty(0.1f) - .rerank(true) - .build(); - // when - String query1 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask1) - .build().buildQuery(); - String query2 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask2) - .build().buildQuery(); - String query3 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask3) - .build().buildQuery(); - String query4 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask4) - .build().buildQuery(); - // then - assertNotNull(query1); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\"}){name}}}", query1); - assertNotNull(query2); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"]}){name}}}", query2); - assertNotNull(query3); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"] certainty:0.1}){name}}}", query3); - assertNotNull(query4); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"] certainty:0.1 rerank:true}){name}}}", query4); - } - - @Test - public void testBuildGetWithAskAndDistance() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - AskArgument ask1 = AskArgument.builder() - .question("Who are you?") - .build(); - AskArgument ask2 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .build(); - AskArgument ask3 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .distance(0.1f) - .build(); - AskArgument ask4 = AskArgument.builder() - .question("Who are you?") - .properties(new String[]{"prop1", "prop2"}) - .distance(0.1f) - .rerank(true) - .build(); - // when - String query1 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask1) - .build().buildQuery(); - String query2 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask2) - .build().buildQuery(); - String query3 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask3) - .build().buildQuery(); - String query4 = GetBuilder.builder() - .className("Pizza").fields(fields).withAskArgument(ask4) - .build().buildQuery(); - // then - assertNotNull(query1); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\"}){name}}}", query1); - assertNotNull(query2); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"]}){name}}}", query2); - assertNotNull(query3); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"] distance:0.1}){name}}}", query3); - assertNotNull(query4); - assertEquals("{Get{Pizza(ask:{question:\"Who are you?\" properties:[\"prop1\",\"prop2\"] distance:0.1 rerank:true}){name}}}", query4); - } - - @Test - public void testBuildGetWithNearImageAndCertainty() throws FileNotFoundException { - // given - File imageFile = new File("src/test/resources/image/pixel.png"); - String base64File = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/image/base64.txt"))) - .lines().collect(Collectors.joining("\n")); - String image = "data:image/png;base64,iVBORw0KGgoAAAANS"; - String expectedImage = "iVBORw0KGgoAAAANS"; - NearImageArgument nearImage1 = NearImageArgument.builder().imageFile(imageFile).build(); - NearImageArgument nearImage2 = NearImageArgument.builder().imageFile(imageFile).certainty(0.4f).build(); - NearImageArgument nearImage3 = NearImageArgument.builder().image(image).certainty(0.1f).build(); - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - // when - String query1 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage1) - .build().buildQuery(); - String query2 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage2) - .build().buildQuery(); - String query3 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage3).limit(1) - .build().buildQuery(); - assertNotNull(query1); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\"}){name}}}", base64File), query1); - assertNotNull(query2); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\" certainty:0.4}){name}}}", base64File), query2); - assertNotNull(query3); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\" certainty:0.1} limit:1){name}}}", expectedImage), query3); - } - - @Test - public void testBuildGetWithNearImageAndDistance() throws FileNotFoundException { - // given - File imageFile = new File("src/test/resources/image/pixel.png"); - String base64File = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/image/base64.txt"))) - .lines().collect(Collectors.joining("\n")); - String image = "data:image/png;base64,iVBORw0KGgoAAAANS"; - String expectedImage = "iVBORw0KGgoAAAANS"; - NearImageArgument nearImage1 = NearImageArgument.builder().imageFile(imageFile).build(); - NearImageArgument nearImage2 = NearImageArgument.builder().imageFile(imageFile).distance(0.4f).build(); - NearImageArgument nearImage3 = NearImageArgument.builder().image(image).distance(0.1f).build(); - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - // when - String query1 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage1) - .build().buildQuery(); - String query2 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage2) - .build().buildQuery(); - String query3 = GetBuilder.builder() - .className("Pizza").fields(fields).withNearImageFilter(nearImage3).limit(1) - .build().buildQuery(); - assertNotNull(query1); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\"}){name}}}", base64File), query1); - assertNotNull(query2); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\" distance:0.4}){name}}}", base64File), query2); - assertNotNull(query3); - assertEquals(String.format("{Get{Pizza(nearImage:{image:\"%s\" distance:0.1} limit:1){name}}}", expectedImage), query3); - } - - @Test - public void testBuildGetWithSort() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - SortArgument sort1 = SortArgument.builder().path(new String[]{"property1"}).build(); - SortArgument sort2 = SortArgument.builder().path(new String[]{"property2"}).order(SortOrder.desc).build(); - SortArgument sort3 = SortArgument.builder().path(new String[]{"property3"}).order(SortOrder.asc).build(); - // when - String query1 = GetBuilder.builder().className("Pizza").fields(fields) - .withSortArguments(SortArguments.builder().sort(new SortArgument[]{sort1}).build()) - .build().buildQuery(); - String query2 = GetBuilder.builder().className("Pizza").fields(fields) - .withSortArguments(SortArguments.builder().sort(new SortArgument[]{sort1, sort2}).build()) - .build().buildQuery(); - String query3 = GetBuilder.builder().className("Pizza").fields(fields) - .withSortArguments(SortArguments.builder().sort(new SortArgument[]{sort1, sort2, sort3}).build()) - .build().buildQuery(); - // then - assertNotNull(query1); - assertEquals("{Get{Pizza(sort:[{path:[\"property1\"]}]){name}}}", query1); - assertEquals("{Get{Pizza(sort:[{path:[\"property1\"]},{path:[\"property2\"] order:desc}]){name}}}", query2); - assertEquals("{Get{Pizza(sort:[{path:[\"property1\"]},{path:[\"property2\"] order:desc},{path:[\"property3\"] order:asc}]){name}}}", query3); - } - - @Test - public void testBuildGetWithConsistencyLevel() { - // given - Fields fields = Fields.builder() - .fields(new Field[]{Field.builder().name("name").build()}) - .build(); - // when - String withAll = GetBuilder.builder().className("Pizza").fields(fields) - .withConsistencyLevel(ConsistencyLevel.ALL) - .build().buildQuery(); - String withQuorum = GetBuilder.builder().className("Pizza").fields(fields) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .build().buildQuery(); - String withOne = GetBuilder.builder().className("Pizza").fields(fields) - .withConsistencyLevel(ConsistencyLevel.ONE) - .build().buildQuery(); - // then - assertEquals("{Get{Pizza(consistencyLevel:ALL){name}}}", withAll); - assertEquals("{Get{Pizza(consistencyLevel:QUORUM){name}}}", withQuorum); - assertEquals("{Get{Pizza(consistencyLevel:ONE){name}}}", withOne); - } - - @Test - public void shouldBuildGetWithGenerativeSearchAndMultipleFieldsIncludingAdditional() { - // given - Fields fields = Fields.builder().fields(new Field[]{ - Field.builder().name("name").build(), - Field.builder().name("description").build(), - Field.builder().name("_additional").fields(new Field[]{ - Field.builder().name("id").build() - }).build() - }).build(); - - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .withGenerativeSearch( - GenerativeSearchBuilder.builder() - .singleResultPrompt("What is the meaning of life?") - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .build() - ) - .build().buildQuery(); - - // then - assertThat(query).isEqualTo("{Get{Pizza{name description _additional{id generate(" + - "singleResult:{prompt:\"\"\"What is the meaning of life?\"\"\"} " + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\"})" + - "{singleResult groupedResult error}}}}}"); - } - - @Test - public void shouldBuildGetWithGenerativeSearchWithPropertiesAndMultipleFieldsIncludingAdditional() { - // given - Fields fields = Fields.builder().fields(new Field[]{ - Field.builder().name("name").build(), - Field.builder().name("description").build(), - Field.builder().name("_additional").fields(new Field[]{ - Field.builder().name("id").build() - }).build() - }).build(); - - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .withGenerativeSearch( - GenerativeSearchBuilder.builder() - .singleResultPrompt("What is the meaning of life?") - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .groupedResultProperties(new String[]{"title", "content"}) - .build() - ) - .build().buildQuery(); - - // then - assertThat(query).isEqualTo("{Get{Pizza{name description _additional{id generate(" + - "singleResult:{prompt:\"\"\"What is the meaning of life?\"\"\"} " + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\" properties:[\"title\",\"content\"]})" + - "{singleResult groupedResult error}}}}}"); - } - - @Test - public void shouldBuildGetWithGenerativeSearchAndMultipleFields() { - // given - Fields fields = Fields.builder().fields(new Field[]{ - Field.builder().name("name").build(), - Field.builder().name("description").build() - }).build(); - - // when - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .withGenerativeSearch( - GenerativeSearchBuilder.builder() - .singleResultPrompt("What is the meaning of life?") - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .build() - ) - .build().buildQuery(); - - // then - assertThat(query).isEqualTo("{Get{Pizza{name description _additional{generate(" + - "singleResult:{prompt:\"\"\"What is the meaning of life?\"\"\"} " + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\"})" + - "{singleResult groupedResult error}}}}}"); - } - - @Test - public void shouldSupportDeprecatedWhereFilter() { - WhereFilter where = WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[]{"good"}) - .build(); - Integer limit = 2; - - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .withNearTextFilter(nearText) - .withWhereFilter(where) - .limit(limit) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{Pizza(where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal} nearText:{concepts:[\"good\"]} limit:2){name}}}"); - } - - @Test - public void testBuildGetWithGroupBy() { - // given - Field[] hits = new Field[]{ - Field.builder().name("prop1").build(), - Field.builder().name("_additional{distance}").build(), - }; - - Field group = Field.builder() - .name("group") - .fields(new Field[]{ - Field.builder().name("groupValue").build(), - Field.builder().name("count").build(), - Field.builder().name("maxDistance").build(), - Field.builder().name("minDistance").build(), - Field.builder().name("hits").fields(hits).build(), - }).build(); - - Fields fields = Fields.builder().fields(new Field[]{ - Field.builder().name("_additional").fields(new Field[]{group}).build() - }).build(); - - GroupByArgument groupBy1 = GroupByArgument.builder().path(new String[]{"prop1"}).build(); - GroupByArgument groupBy2 = GroupByArgument.builder().path(new String[]{"prop1"}).groups(1).objectsPerGroup(3).build(); - // when - String query1 = GetBuilder.builder().className("Pizza").fields(fields) - .withGroupByArgument(groupBy1) - .build().buildQuery(); - String query2 = GetBuilder.builder().className("Pizza").fields(fields) - .withGroupByArgument(groupBy2) - .build().buildQuery(); - // then - assertNotNull(query1); - assertEquals("{Get{Pizza(groupBy:{path:[\"prop1\"]}){_additional{group{groupValue count maxDistance minDistance hits{prop1 _additional{distance}}}}}}}", query1); - assertEquals("{Get{Pizza(groupBy:{path:[\"prop1\"] groups:1 objectsPerGroup:3}){_additional{group{groupValue count maxDistance minDistance hits{prop1 _additional{distance}}}}}}}", query2); - } - - @Test - public void shouldBuildGetWithTenant() { - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .tenant("TenantNo1") - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{Pizza(tenant:\"TenantNo1\"){name}}}"); - } - - @Test - public void shouldBuildGetWithTenantAndWhere() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .tenant("TenantNo1") - .withWhereFilter(where) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{Pizza(tenant:\"TenantNo1\" where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal}){name}}}"); - } - - @Test - public void shouldBuildGetWithAutocut() { - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .autocut(2) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{Pizza(autocut:2){name}}}"); - } - - @Test - public void shouldBuildGetWithAutocutAndWhere() { - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"name"}) - .operator(Operator.Equal) - .valueText("Hawaii") - .build()) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("Pizza") - .fields(fields) - .autocut(2) - .withWhereFilter(where) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{Pizza(where:{path:[\"name\"] valueText:\"Hawaii\" operator:Equal} autocut:2){name}}}"); - } - - @Test - public void shouldBuildGetWithNearAudio() { - NearAudioArgument nearAudio = NearAudioArgument.builder() - .audio("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("PizzaAudio") - .fields(fields) - .withNearAudioFilter(nearAudio) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{PizzaAudio(nearAudio:{audio:\"iVBORw0KGgoAAAANS\" distance:0.1}){name}}}"); - } - - @Test - public void shouldBuildGetWithNearVideo() { - NearVideoArgument nearVideo = NearVideoArgument.builder() - .video("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("PizzaVideo") - .fields(fields) - .withNearVideoFilter(nearVideo) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{PizzaVideo(nearVideo:{video:\"iVBORw0KGgoAAAANS\" distance:0.1}){name}}}"); - } - - @Test - public void shouldBuildGetWithNearDepth() { - NearDepthArgument nearDepth = NearDepthArgument.builder() - .depth("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("PizzaDepth") - .fields(fields) - .withNearDepthFilter(nearDepth) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{PizzaDepth(nearDepth:{depth:\"iVBORw0KGgoAAAANS\" distance:0.1}){name}}}"); - } - - @Test - public void shouldBuildGetWithNearThermal() { - NearThermalArgument nearThermal = NearThermalArgument.builder() - .thermal("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("PizzaThermal") - .fields(fields) - .withNearThermalFilter(nearThermal) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{PizzaThermal(nearThermal:{thermal:\"iVBORw0KGgoAAAANS\" distance:0.1}){name}}}"); - } - - @Test - public void shouldBuildGetWithNearImu() { - NearImuArgument nearImu = NearImuArgument.builder() - .imu("iVBORw0KGgoAAAANS") - .distance(0.1f) - .build(); - Fields fields = Fields.builder() - .fields(Field.builder().name("name").build()) - .build(); - - String query = GetBuilder.builder() - .className("PizzaImu") - .fields(fields) - .withNearImuFilter(nearImu) - .build().buildQuery(); - - assertThat(query).isEqualTo("{Get{PizzaImu(nearIMU:{imu:\"iVBORw0KGgoAAAANS\" distance:0.1}){name}}}"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldTest.java deleted file mode 100644 index 61100b74f..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldTest.java +++ /dev/null @@ -1,78 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -public class FieldTest { - - @Test - public void testBuild() { - // given - String expected = "_additional{certainty}"; - Field field = Field.builder() - .name("_additional") - .fields(new Field[]{ Field.builder().name("certainty").build() }) - .build(); - // when - String fieldString = field.build(); - // then - assertEquals(expected, fieldString); - } - - @Test - public void testBuild2() { - // given - String expected = "_additional{classification{basedOn classifiedFields completed id scope}}"; - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[]{ - Field.builder() - .name("classification") - .fields(new Field[]{ - Field.builder().name("basedOn").build(), - Field.builder().name("classifiedFields").build(), - Field.builder().name("completed").build(), - Field.builder().name("id").build(), - Field.builder().name("scope").build() - }).build() - }).build(); - // when - String fieldString = _additional.build(); - // then - assertEquals(expected, fieldString); - } - - @Test - public void testBuild3() { - // given - String expected = "inPublication{... on Publication{name}}"; - Field field = Field.builder() - .name("inPublication") - .fields(new Field[]{ - Field.builder() - .name("... on Publication") - .fields(new Field[]{ - Field.builder().name("name").build() - }).build() - }).build(); - // when - String fieldString = field.build(); - // then - assertEquals(expected, fieldString); - } - - @Test - public void testBuild4() { - // given - String expected = "_additional{distance}"; - Field field = Field.builder() - .name("_additional") - .fields(new Field[]{ Field.builder().name("distance").build() }) - .build(); - // when - String fieldString = field.build(); - // then - assertEquals(expected, fieldString); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldsTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldsTest.java deleted file mode 100644 index 1b36c8dda..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/fields/FieldsTest.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import junit.framework.TestCase; -import org.junit.Assert; -import org.junit.Test; - -public class FieldsTest extends TestCase { - - @Test - public void testBuild() { - // given - String expected = "a b c"; - Field a = Field.builder().name("a").build(); - Field b = Field.builder().name("b").build(); - Field c = Field.builder().name("c").build(); - Fields fields = Fields.builder().fields(new Field[]{ a, b, c }).build(); - // when - String fieldsParameter = fields.build(); - // then - Assert.assertEquals(expected, fieldsParameter); - } - - @Test - public void testBuildNested() { - // given - String expected = "a{b} c{d{e}}"; - Field b = Field.builder().name("b").build(); - Field a = Field.builder() - .name("a") - .fields(new Field[]{b}) - .build(); - Field c = Field.builder() - .name("c") - .fields(new Field[]{Field.builder() - .name("d") - .fields(new Field[]{Field.builder().name("e").build()}) - .build()}).build(); - Fields fields = Fields.builder().fields(new Field[]{ a, c }).build(); - // when - String fieldsParameter = fields.build(); - // then - Assert.assertEquals(expected, fieldsParameter); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilderTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilderTest.java deleted file mode 100644 index e36017fac..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/fields/GenerativeSearchBuilderTest.java +++ /dev/null @@ -1,117 +0,0 @@ -package io.weaviate.client.v1.graphql.query.fields; - -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; - -public class GenerativeSearchBuilderTest { - - @Test - public void shouldBuildEmptyField() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isBlank(); - assertThat(generate.getFields()).isNull(); - } - - @Test - public void shouldBuildSingleResultPromptField() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .singleResultPrompt("What is the meaning of life?") - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "singleResult:{prompt:\"\"\"What is the meaning of life?\"\"\"}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("singleResult", "error"); - } - - @Test - public void shouldBuildGroupedResultTaskField() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\"}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("groupedResult", "error"); - } - - @Test - public void shouldBuildBothSingleResultPromptAndGroupedResultTaskField() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .singleResultPrompt("What is the meaning of life?") - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "singleResult:{prompt:\"\"\"What is the meaning of life?\"\"\"} " + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\"}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("singleResult", "groupedResult", "error"); - } - - @Test - public void shouldBuildBothSingleResultPromptAndGroupedResultTaskFieldWithChars() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .singleResultPrompt("\"I'm a complex string\" says the {'`:string:`'}") - .groupedResultTask("\"I'm a complex string\" says the {'`:string:`'}") - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "singleResult:{prompt:\"\"\"\\\"I'm a complex string\\\" says the {'`:string:`'}\"\"\"} " + - "groupedResult:{task:\"\"\"\\\"I'm a complex string\\\" says the {'`:string:`'}\"\"\"}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("singleResult", "groupedResult", "error"); - } - - @Test - public void shouldBuildGroupedResultTaskFieldAndProperties() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .groupedResultTask("Explain why these magazines or newspapers are about finance") - .groupedResultProperties(new String[]{"property1", "property2"}) - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "groupedResult:{task:\"\"\"Explain why these magazines or newspapers are about finance\"\"\" properties:[\"property1\",\"property2\"]}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("groupedResult", "error"); - } - - @Test - public void shouldBuildBothSingleResultPromptAndGroupedResultTaskFieldWithCharsAndProperties() { - GenerativeSearchBuilder generativeSearchBuilder = GenerativeSearchBuilder.builder() - .singleResultPrompt("\"I'm a complex string\" says the {'`:string:`'}") - .groupedResultTask("\"I'm a complex string\" says the {'`:string:`'}") - .groupedResultProperties(new String[]{"content"}) - .build(); - - Field generate = generativeSearchBuilder.build(); - - assertThat(generate.getName()).isEqualTo("generate(" + - "singleResult:{prompt:\"\"\"\\\"I'm a complex string\\\" says the {'`:string:`'}\"\"\"} " + - "groupedResult:{task:\"\"\"\\\"I'm a complex string\\\" says the {'`:string:`'}\"\"\" properties:[\"content\"]}" + - ")"); - assertThat(generate.getFields()).extracting(Field::getName) - .containsExactly("singleResult", "groupedResult", "error"); - } -} diff --git a/src/test/java/io/weaviate/client/v1/graphql/query/util/SerializerTest.java b/src/test/java/io/weaviate/client/v1/graphql/query/util/SerializerTest.java deleted file mode 100644 index 782093a54..000000000 --- a/src/test/java/io/weaviate/client/v1/graphql/query/util/SerializerTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package io.weaviate.client.v1.graphql.query.util; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import org.junit.Test; -import org.junit.runner.RunWith; - -import static org.assertj.core.api.Assertions.assertThat; - -@RunWith(JParamsTestRunner.class) -public class SerializerTest { - - @Test - @DataMethod(source = SerializerTest.class, method = "provideForEscape") - public void shouldEscapeString(String input, String expected) { - String escaped = Serializer.escape(input); - - assertThat(escaped).isEqualTo(expected); - } - - public static Object[][] provideForEscape() { - return new Object[][] { - new Object[] { - "I'm a string with double \"quotes\"", - "I'm a string with double \\\"quotes\\\"", - }, - new Object[] { - "I'm a string with curly {brackets} and :colons:", - "I'm a string with curly {brackets} and :colons:", - }, - new Object[] { - "I'm a string with single 'quotes' and `backticks`", - "I'm a string with single 'quotes' and `backticks`", - }, - new Object[] { - "", - "", - }, - new Object[] { - null, - "", - }, - }; - } - - @Test - @DataMethod(source = SerializerTest.class, method = "provideForQuote") - public void shouldQuoteString(String input, String expected) { - String quoted = Serializer.quote(input); - - assertThat(quoted).isEqualTo(expected); - } - - public static Object[][] provideForQuote() { - return new Object[][] { - new Object[] { - "I'm a string with double \"quotes\"", - "\"I'm a string with double \\\"quotes\\\"\"", - }, - new Object[] { - "I'm a string with curly {brackets} and :colons:", - "\"I'm a string with curly {brackets} and :colons:\"", - }, - new Object[] { - "I'm a string with single 'quotes' and `backticks`", - "\"I'm a string with single 'quotes' and `backticks`\"", - }, - new Object[] { - "", - "\"\"", - }, - new Object[] { - null, - "", - }, - }; - } - - @Test - @DataMethod(source = SerializerTest.class, method = "provideForArrayQuotes") - public void shouldBuildArrayWithQuotes(String[] input, String expected) { - String arrayQuotes = Serializer.arrayWithQuotes(input); - - assertThat(arrayQuotes).isEqualTo(expected); - } - - public static Object[][] provideForArrayQuotes() { - return new Object[][] { - new Object[]{ - new String[]{"some string", "other string"}, - "[\"some string\",\"other string\"]", - }, - new Object[]{ - new String[]{ - "I'm a string with double \"quotes\"", - "I'm a string with curly {brackets} and :colons:", - "I'm a string with single 'quotes' and `backticks`", - }, - "[\"I'm a string with double \\\"quotes\\\"\"," + - "\"I'm a string with curly {brackets} and :colons:\"," + - "\"I'm a string with single 'quotes' and `backticks`\"]" - }, - new Object[] { - new String[]{}, - "[]", - }, - new Object[] { - null, - "[]", - }, - }; - } - - @Test - @DataMethod(source = SerializerTest.class, method = "provideForArray") - public void shouldBuildArray(Object[] input, String expected) { - String array = Serializer.array(input); - - assertThat(array).isEqualTo(expected); - } - - public static Object[][] provideForArray() { - return new Object[][] { - new Object[]{ - new Float[]{ .1f, .2f, .3f }, - "[0.1,0.2,0.3]", - }, - new Object[]{ - new Float[]{}, - "[]", - }, - new Object[]{ - null, - "[]", - } - }; - } -} diff --git a/src/test/java/io/weaviate/client/v1/grpc/GRPCTest.java b/src/test/java/io/weaviate/client/v1/grpc/GRPCTest.java deleted file mode 100644 index 270ebcc1a..000000000 --- a/src/test/java/io/weaviate/client/v1/grpc/GRPCTest.java +++ /dev/null @@ -1,48 +0,0 @@ -package io.weaviate.client.v1.grpc; - -import static org.junit.Assert.assertArrayEquals; - -import org.junit.Test; - -import com.google.protobuf.ByteString; - -/** - * Note: Java's {@code byte} is signed (int8) and is different from {@code byte} - * in Go, which is an alias for uint8. - * - * For this tests purposes the distinction is immaterial, as "want" arrays - * are "golden values" meant to be a readable respresentation for the test. - */ -public class GRPCTest { - @Test - public void test_toBytesString_1d() { - Float[] vector = { 1f, 2f, 3f }; - byte[] want = { 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64 }; - byte[] got = GRPC.toByteString(vector).toByteArray(); - assertArrayEquals(want, got); - } - - @Test - public void test_fromBytesString_1d() { - byte[] bytes = { 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64 }; - Float[] want = { 1f, 2f, 3f }; - Float[] got = GRPC.fromByteString(ByteString.copyFrom(bytes)); - assertArrayEquals(want, got); - } - - @Test - public void test_toBytesString_multi() { - Float[][] vector = { { 1f, 2f, 3f }, { 4f, 5f, 6f } }; - byte[] want = { 3, 0, 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64, 0, 0, -96, 64, 0, 0, -64, 64 }; - byte[] got = GRPC.toByteString(vector).toByteArray(); - assertArrayEquals(want, got); - } - - @Test - public void test_fromBytesString_multi() { - byte[] bytes = { 3, 0, 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64, 0, 0, -96, 64, 0, 0, -64, 64 }; - Float[][] want = { { 1f, 2f, 3f }, { 4f, 5f, 6f } }; - Float[][] got = GRPC.fromByteStringMulti(ByteString.copyFrom(bytes)); - assertArrayEquals(want, got); - } -} diff --git a/src/test/java/io/weaviate/client/v1/rbac/api/WeaviatePermissionTest.java b/src/test/java/io/weaviate/client/v1/rbac/api/WeaviatePermissionTest.java deleted file mode 100644 index dc4eb691b..000000000 --- a/src/test/java/io/weaviate/client/v1/rbac/api/WeaviatePermissionTest.java +++ /dev/null @@ -1,122 +0,0 @@ -package io.weaviate.client.v1.rbac.api; - -import static org.junit.jupiter.api.Assertions.assertArrayEquals; - -import java.util.Arrays; - -import org.junit.Test; - -import io.weaviate.client.v1.rbac.model.AliasPermission; -import io.weaviate.client.v1.rbac.model.BackupsPermission; -import io.weaviate.client.v1.rbac.model.ClusterPermission; -import io.weaviate.client.v1.rbac.model.CollectionsPermission; -import io.weaviate.client.v1.rbac.model.DataPermission; -import io.weaviate.client.v1.rbac.model.GroupsPermission; -import io.weaviate.client.v1.rbac.model.NodesPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.ReplicatePermission; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.rbac.model.RolesPermission; -import io.weaviate.client.v1.rbac.model.TenantsPermission; -import io.weaviate.client.v1.rbac.model.UsersPermission; - -public class WeaviatePermissionTest { - /** - * When serialized to the API request body, permissions must be "flattened", - * i.e. a single action per permission. When the response is deserialised, - * permissions with for the same resource should be grouped together. - */ - @Test - public void testMergedPermissions() { - WeaviatePermission[] apiPermissions = { - // Create and delete PizzaAlias alias - new WeaviatePermission("create_aliases", new AliasPermission("PizzaAlias", "Pizza")), - new WeaviatePermission("delete_aliases", new AliasPermission("PizzaAlias", "Pizza")), - - // Manage Pizza backups - new WeaviatePermission("manage_backups", new BackupsPermission("Pizza")), - - // Manage and read Pizza data - new WeaviatePermission("manage_data", new DataPermission("Pizza")), - new WeaviatePermission("read_data", new DataPermission("Pizza")), - - // Update and delete Songs data - new WeaviatePermission("update_data", new DataPermission("Songs")), - new WeaviatePermission("delete_data", new DataPermission("Songs")), - - // Read nodes with Pizza collection - new WeaviatePermission("read_nodes", new NodesPermission("Pizza")), - - // Read nodes for any collection with verbosity="verbose" - new WeaviatePermission("read_nodes", new NodesPermission(NodesPermission.Verbosity.VERBOSE)), - - // Read Reader role - new WeaviatePermission("read_roles", new RolesPermission("Reader")), - - // Create and update CreatorUpdater role - new WeaviatePermission("create_roles", new RolesPermission("CreatorUpdater", RolesPermission.Scope.ALL)), - new WeaviatePermission("update_roles", new RolesPermission("CreatorUpdater", RolesPermission.Scope.ALL)), - - // Delete and update Pizza collection definition - new WeaviatePermission("delete_collections", new CollectionsPermission("Pizza")), - new WeaviatePermission("update_collections", new CollectionsPermission("Pizza")), - - // Read Songs collection definition - new WeaviatePermission("read_collections", new CollectionsPermission("Songs")), - - // Read clusters - new WeaviatePermission("read_cluster", new ClusterPermission()), - - // Create and update tenants - new WeaviatePermission("create_tenants", new TenantsPermission()), - new WeaviatePermission("update_tenants", new TenantsPermission()), - - // Read and delete users - new WeaviatePermission("read_users", new UsersPermission()), - new WeaviatePermission("assign_and_revoke_users", new UsersPermission()), - - // Create and update replications - new WeaviatePermission("create_replicate", new ReplicatePermission("Pizza", "shard-123")), - new WeaviatePermission("update_replicate", new ReplicatePermission("Pizza", "shard-123")), - - // Create and update replications - new WeaviatePermission("read_groups", new GroupsPermission("pizza-lovers", "oidc")), - new WeaviatePermission("assign_and_revoke_groups", new GroupsPermission("pizza-lovers", "oidc")), - }; - - Permission[] libraryPermissions = { - new AliasPermission("PizzaAlias", "Pizza", AliasPermission.Action.CREATE, AliasPermission.Action.DELETE), - new BackupsPermission("Pizza", BackupsPermission.Action.MANAGE), - new DataPermission("Pizza", DataPermission.Action.MANAGE, DataPermission.Action.READ), - new DataPermission("Songs", DataPermission.Action.UPDATE, DataPermission.Action.DELETE), - new NodesPermission("Pizza", NodesPermission.Action.READ), - new NodesPermission(NodesPermission.Verbosity.VERBOSE, NodesPermission.Action.READ), - new RolesPermission("Reader", RolesPermission.Action.READ), - new RolesPermission("CreatorUpdater", RolesPermission.Scope.ALL, - RolesPermission.Action.CREATE, RolesPermission.Action.UPDATE), - new CollectionsPermission("Pizza", CollectionsPermission.Action.DELETE, CollectionsPermission.Action.UPDATE), - new CollectionsPermission("Songs", CollectionsPermission.Action.READ), - new ClusterPermission(ClusterPermission.Action.READ), - new TenantsPermission(TenantsPermission.Action.CREATE, TenantsPermission.Action.UPDATE), - new UsersPermission(UsersPermission.Action.READ, UsersPermission.Action.ASSIGN_AND_REVOKE), - new ReplicatePermission("Pizza", "shard-123", ReplicatePermission.Action.CREATE, - ReplicatePermission.Action.UPDATE), - new GroupsPermission("pizza-lovers", "oidc", GroupsPermission.Action.READ, - GroupsPermission.Action.ASSIGN_AND_REVOKE), - }; - - { - WeaviateRole role = new WeaviateRole("TestRole", - Arrays.asList(libraryPermissions)); - WeaviatePermission[] got = role.getPermissions().toArray(new WeaviatePermission[] {}); - assertArrayEquals(apiPermissions, got, "lib -> api conversion"); - } - - { - WeaviateRole role = new WeaviateRole("TestRole", apiPermissions); - Role libRole = role.toRole(); - Permission[] got = libRole.permissions.toArray(new Permission[] {}); - assertArrayEquals(libraryPermissions, got, "api -> lib conversion"); - } - } -} diff --git a/src/test/java/io/weaviate/client/v1/rbac/model/PermissionTest.java b/src/test/java/io/weaviate/client/v1/rbac/model/PermissionTest.java deleted file mode 100644 index b6082469f..000000000 --- a/src/test/java/io/weaviate/client/v1/rbac/model/PermissionTest.java +++ /dev/null @@ -1,244 +0,0 @@ -package io.weaviate.client.v1.rbac.model; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertThrows; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; - -import java.util.ArrayList; -import java.util.function.Supplier; - -import org.junit.Test; -import org.junit.function.ThrowingRunnable; -import org.junit.runner.RunWith; -import org.testcontainers.shaded.org.hamcrest.Matcher; -import org.testcontainers.shaded.org.hamcrest.MatcherAssert; -import org.testcontainers.shaded.org.hamcrest.beans.SamePropertyValuesAs; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import com.jparams.junit4.description.Name; - -import io.weaviate.client.v1.rbac.api.WeaviatePermission; - -@RunWith(JParamsTestRunner.class) -public class PermissionTest { - public static Object[][] serializationTestCases() { - AliasPermission alias = new AliasPermission("PizzaAlias", "Pizza", AliasPermission.Action.CREATE); - BackupsPermission backups = new BackupsPermission("Pizza", BackupsPermission.Action.MANAGE); - DataPermission data = new DataPermission("Pizza", DataPermission.Action.MANAGE); - NodesPermission nodes = new NodesPermission("Pizza", NodesPermission.Action.READ); - RolesPermission roles = new RolesPermission("TestWriter", RolesPermission.Action.CREATE); - CollectionsPermission collections = new CollectionsPermission("Pizza", CollectionsPermission.Action.CREATE); - ClusterPermission cluster = new ClusterPermission(ClusterPermission.Action.READ); - TenantsPermission tenants = new TenantsPermission(TenantsPermission.Action.READ); - UsersPermission users = new UsersPermission(UsersPermission.Action.READ); - ReplicatePermission replicate = new ReplicatePermission("Pizza", "shard-123", ReplicatePermission.Action.READ); - GroupsPermission groups = new GroupsPermission("pizza-lovers", "oidc", GroupsPermission.Action.READ); - - return new Object[][] { - { - "alias permission", - (Supplier>) () -> alias, - new WeaviatePermission("create_aliases", alias), - }, - { - "backup permission", - (Supplier>) () -> backups, - new WeaviatePermission("manage_backups", backups), - }, - { - "data permission", - (Supplier>) () -> data, - new WeaviatePermission("manage_data", data), - }, - { - "nodes permission", - (Supplier>) () -> nodes, - new WeaviatePermission("read_nodes", nodes), - }, - { - "roles permission", - (Supplier>) () -> roles, - new WeaviatePermission("create_roles", roles), - }, - { - "collections permission", - (Supplier>) () -> collections, - new WeaviatePermission("create_collections", collections), - }, - { - "cluster permission", - (Supplier>) () -> cluster, - new WeaviatePermission("read_cluster"), - }, - { - "tenants permission", - (Supplier>) () -> tenants, - new WeaviatePermission("read_tenants", tenants), - }, - { - "users permission", - (Supplier>) () -> users, - new WeaviatePermission("read_users", users), - }, - { - "replicate permission", - (Supplier>) () -> replicate, - new WeaviatePermission("read_replicate", replicate), - }, - { - "groups permission", - (Supplier>) () -> groups, - new WeaviatePermission("read_groups", groups), - }, - }; - } - - @DataMethod(source = PermissionTest.class, method = "serializationTestCases") - @Name("{0}") - @Test - public void testFirstToWeaviate(String name, Supplier> permFunc, WeaviatePermission expected) - throws Exception { - Permission perm = permFunc.get(); - MatcherAssert.assertThat(name, perm.firstToWeaviate(), sameAs(expected)); - } - - private static Matcher sameAs(T expected) { - return new SamePropertyValuesAs(expected, new ArrayList<>()); - } - - @Test - public void testDefaultNodesPermission() { - NodesPermission perm = new NodesPermission(NodesPermission.Verbosity.MINIMAL, NodesPermission.Action.READ); - assertThat(perm).as("nodes permission should affect all collections if one is not specified") - .returns("*", NodesPermission::getCollection); - } - - @Test - public void testDefaultRolesPermission() { - RolesPermission perm = new RolesPermission("ExampleRole", RolesPermission.Action.READ); - assertThat(perm).as("roles permission must have scope=null") - .returns(null, RolesPermission::getScope); - } - - @Test - public void testDefaultReplicatePermission() { - ReplicatePermission perm = new ReplicatePermission("Pizza", null); - assertThat(perm).as("replicate permission returns shard=* on read if one is not specified") - .returns("*", ReplicatePermission::getShard); - } - - @DataMethod(source = PermissionTest.class, method = "serializationTestCases") - @Name("{0}") - @Test - public void testFromWeaviate(String name, - Supplier> expectedFunc, WeaviatePermission input) - throws Exception { - Permission expected = expectedFunc.get(); - Permission actual = Permission.fromWeaviate(input); - MatcherAssert.assertThat(name, actual, sameAs(expected)); - } - - /** - * groupedConstructors returns test cases for overloaded factory methods, which - * allow creating multiple permission entries for the same resource. - * - * Permission types which only have 1 possible action (e.g. backup/cluster - * permissions) are omitted. - */ - public static Object[][] groupedConstructors() { - return new Object[][] { - { - Permission.collections("Pizza", - CollectionsPermission.Action.CREATE, - CollectionsPermission.Action.READ, - CollectionsPermission.Action.DELETE), - new String[] { - "create_collections", - "read_collections", - "delete_collections", - }, - }, - { - Permission.data("Pizza", - DataPermission.Action.CREATE, - DataPermission.Action.READ, - DataPermission.Action.DELETE), - new String[] { - "create_data", - "read_data", - "delete_data", - }, - }, - { - Permission.roles("TestRole", - RolesPermission.Action.READ, - RolesPermission.Action.UPDATE), - new String[] { - "read_roles", - "update_roles", - }, - }, - { - Permission.alias("PizzaAlias", "Pizza", - AliasPermission.Action.CREATE, - AliasPermission.Action.READ, - AliasPermission.Action.UPDATE, - AliasPermission.Action.DELETE), - new String[] { - "create_aliases", - "read_aliases", - "update_aliases", - "delete_aliases", - }, - }, - { - Permission.replicate("Pizza", "shard-123", - ReplicatePermission.Action.CREATE, - ReplicatePermission.Action.READ, - ReplicatePermission.Action.UPDATE, - ReplicatePermission.Action.DELETE), - new String[] { - "create_replicate", - "read_replicate", - "update_replicate", - "delete_replicate", - }, - }, - { - Permission.groups("group-id", "oidc", - GroupsPermission.Action.READ, - GroupsPermission.Action.ASSIGN_AND_REVOKE), - new String[] { - "read_groups", - "assign_and_revoke_groups", - }, - }, - }; - } - - @DataMethod(source = PermissionTest.class, method = "groupedConstructors") - @Name("{0}") - @Test - public void testGroupedConstructors(Permission> permission, String[] expectedActions) { - Object[] actualActions = permission.getActions().toArray(); - assertArrayEquals(expectedActions, actualActions, "set of allowed actions do not match"); - } - - public static Object[][] deprecatedActions() { - return new Object[][] { - { (ThrowingRunnable) () -> Permission.roles("AnyRole", RolesPermission.Action.MANAGE) }, - }; - } - - /** - * Passing deprecated actions, e.g {@link RolesPermission.Action.MANAGE}, will - * result in an error, and we can prevent that sooner. - */ - @DataMethod(source = PermissionTest.class, method = "deprecatedActions") - @Test - public void testDeprecatedActions(ThrowingRunnable r) { - assertThrows(IllegalArgumentException.class, r); - - } -} diff --git a/src/test/java/io/weaviate/client/v1/schema/model/PropertyTest.java b/src/test/java/io/weaviate/client/v1/schema/model/PropertyTest.java deleted file mode 100644 index c9517b22b..000000000 --- a/src/test/java/io/weaviate/client/v1/schema/model/PropertyTest.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import com.google.gson.GsonBuilder; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import junit.framework.TestCase; -import org.junit.Test; - -public class PropertyTest extends TestCase { - - @Test - public void testSerialize() { - // given - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("vectorizePropertyName", false); - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - Property priceProperty = Property.builder() - .dataType(Arrays.asList(DataType.NUMBER)) - .description("price") - .name("price") - .moduleConfig(moduleConfig) - .build(); - String expected = "{\"name\":\"price\",\"dataType\":[\"number\"],\"description\":\"price\"," + - "\"moduleConfig\":{\"text2vec-contextionary\":{\"vectorizePropertyName\":false}}}"; - // when - String result = new GsonBuilder().create().toJson(priceProperty); - // then - assertNotNull(result); - assertEquals(expected, result); - } -} diff --git a/src/test/java/io/weaviate/client/v1/schema/model/WeaviateClassTest.java b/src/test/java/io/weaviate/client/v1/schema/model/WeaviateClassTest.java deleted file mode 100644 index 5ea55a561..000000000 --- a/src/test/java/io/weaviate/client/v1/schema/model/WeaviateClassTest.java +++ /dev/null @@ -1,143 +0,0 @@ -package io.weaviate.client.v1.schema.model; - -import com.google.gson.GsonBuilder; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import java.util.HashMap; -import java.util.Map; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.MAP; -import org.junit.Test; - -public class WeaviateClassTest { - - @Test - public void shouldReturnModuleConfigSetWithLowerCase() { - WeaviateClass clazz = WeaviateClass.builder() - .moduleConfig(createContextionaryModuleConfig()) - .build(); - - Object moduleConfig = clazz.getModuleConfig(); - - assertThat(moduleConfig) - .asInstanceOf(MAP) - .containsOnlyKeys("text2vec-contextionary"); - } - - @Test - public void shouldReturnModuleConfigSetWithUpperCase() { - WeaviateClass clazz = WeaviateClass.builder() - .ModuleConfig(createContextionaryModuleConfig()) - .build(); - - Object moduleConfig = clazz.getModuleConfig(); - - assertThat(moduleConfig) - .asInstanceOf(MAP) - .containsOnlyKeys("text2vec-contextionary"); - } - - @Test - public void shouldSerializeClass() { - WeaviateClass clazz = WeaviateClass.builder() - .moduleConfig(createContextionaryModuleConfig()) - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); - - String result = new GsonBuilder().create().toJson(clazz); - - assertThat(result).isEqualTo("{\"class\":\"Band\",\"description\":\"Band that plays and produces music\"," + - "\"moduleConfig\":{\"text2vec-contextionary\":{\"vectorizeClassName\":false}},\"vectorIndexType\":\"hnsw\"," + - "\"vectorizer\":\"text2vec-contextionary\"}"); - } - - - @Test - public void shouldSerializeClassWithFlatIndexType() { - WeaviateClass clazz = WeaviateClass.builder() - .moduleConfig(createContextionaryModuleConfig()) - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("flat") - .vectorIndexConfig(createBqIndexConfig()) - .vectorizer("text2vec-contextionary") - .build(); - - String result = new GsonBuilder().create().toJson(clazz); - - assertThat(result).isEqualTo("{\"class\":\"Band\",\"description\":\"Band that plays and produces music\"," + - "\"moduleConfig\":{\"text2vec-contextionary\":{\"vectorizeClassName\":false}}," + - "\"vectorIndexConfig\":{\"bq\":{\"enabled\":true,\"rescoreLimit\":100}},\"vectorIndexType\":\"flat\"," + - "\"vectorizer\":\"text2vec-contextionary\"}"); - } - - @Test - public void shouldSerializeClassWithVectorConfig() { - Map contextionaryVectorizer = new HashMap<>(); - contextionaryVectorizer.put("text2vec-contextionary", "some-setting"); - - WeaviateClass.VectorConfig hnswVectorConfig = WeaviateClass.VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(contextionaryVectorizer) - .build(); - WeaviateClass.VectorConfig flatVectorConfig = WeaviateClass.VectorConfig.builder() - .vectorIndexType("flat") - .vectorizer(contextionaryVectorizer) - .vectorIndexConfig(createBqIndexConfig()) - .build(); - - Map vectorConfig = new HashMap<>(); - vectorConfig.put("flatVector", flatVectorConfig); - vectorConfig.put("hnswVector", hnswVectorConfig); - - WeaviateClass clazz = WeaviateClass.builder() - .moduleConfig(createContextionaryModuleConfig()) - .className("Band") - .description("Band that plays and produces music") - .vectorConfig(vectorConfig) - .build(); - - String result = new GsonBuilder().create().toJson(clazz); - - assertThat(result).satisfiesAnyOf( - serialized -> assertThat(serialized).isEqualTo("{\"class\":\"Band\"," + - "\"description\":\"Band that plays and produces music\"," + - "\"moduleConfig\":{\"text2vec-contextionary\":{\"vectorizeClassName\":false}}," + - "\"vectorConfig\":{" + - "\"hnswVector\":{\"vectorIndexType\":\"hnsw\",\"vectorizer\":{\"text2vec-contextionary\":\"some-setting\"}}," + - "\"flatVector\":{\"vectorIndexConfig\":{\"bq\":{\"enabled\":true,\"rescoreLimit\":100}},\"vectorIndexType\":\"flat\"," + - "\"vectorizer\":{\"text2vec-contextionary\":\"some-setting\"}}" + - "}}"), - serialized -> assertThat(serialized).isEqualTo("{\"class\":\"Band\"," + - "\"description\":\"Band that plays and produces music\"," + - "\"moduleConfig\":{\"text2vec-contextionary\":{\"vectorizeClassName\":false}}," + - "\"vectorConfig\":{" + - "\"flatVector\":{\"vectorIndexConfig\":{\"bq\":{\"enabled\":true,\"rescoreLimit\":100}},\"vectorIndexType\":\"flat\"," + - "\"vectorizer\":{\"text2vec-contextionary\":\"some-setting\"}}" + - "\"hnswVector\":{\"vectorIndexType\":\"hnsw\",\"vectorizer\":{\"text2vec-contextionary\":\"some-setting\"}}," + - "}}") - ); - } - - private Object createContextionaryModuleConfig() { - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("vectorizeClassName", false); - - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - - return moduleConfig; - } - - private VectorIndexConfig createBqIndexConfig() { - return VectorIndexConfig.builder() - .bq(BQConfig.builder() - .enabled(true) - .rescoreLimit(100L) - .build()) - .build(); - } -} diff --git a/src/test/java/io/weaviate/client/v1/users/api/WeaviateUserTest.java b/src/test/java/io/weaviate/client/v1/users/api/WeaviateUserTest.java deleted file mode 100644 index 2935a2162..000000000 --- a/src/test/java/io/weaviate/client/v1/users/api/WeaviateUserTest.java +++ /dev/null @@ -1,46 +0,0 @@ -package io.weaviate.client.v1.users.api; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.ArrayList; - -import org.junit.Test; -import org.junit.runner.RunWith; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.base.Serializer; -import io.weaviate.client.v1.users.model.User; - -@RunWith(JParamsTestRunner.class) -public class WeaviateUserTest { - private final Serializer ser = new Serializer(); - - public static Object[][] deserializationTestCases() { - return new Object[][] { - { - "has username, no user_id", - "{\"username\": \"John Doe\"}", - new User("John Doe", new ArrayList<>()), - }, - { - "has user_id, no username", - "{\"user_id\": \"john_doe\"}", - new User("john_doe", new ArrayList<>()), - }, - { - "has both user_id and username", - "{\"user_id\": \"john_doe\", \"username\": \"John Doe\"}", - new User("john_doe", new ArrayList<>()), - }, - }; - } - - @DataMethod(source = WeaviateUserTest.class, method = "deserializationTestCases") - @Test - public void testToUser(String name, String json, User want) { - User got = ser.toResponse(json, WeaviateUser.class).toUser(); - assertEquals(want.getUserId(), got.getUserId(), "user id"); - } -} diff --git a/src/test/java/io/weaviate/client6/v1/api/AuthenticationTest.java b/src/test/java/io/weaviate/client6/v1/api/AuthenticationTest.java new file mode 100644 index 000000000..54472875e --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/AuthenticationTest.java @@ -0,0 +1,68 @@ +package io.weaviate.client6.v1.api; + +import java.io.IOException; +import java.util.Collections; + +import org.assertj.core.api.Assertions; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockserver.integration.ClientAndServer; +import org.mockserver.model.HttpRequest; + +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.client6.v1.internal.rest.DefaultRestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransport; +import io.weaviate.client6.v1.internal.rest.RestTransportOptions; +import io.weaviate.client6.v1.internal.rest.SimpleEndpoint; + +public class AuthenticationTest { + private ClientAndServer mockServer; + private RestTransport noAuthTransport; + + @Before + public void startMockServer() throws IOException { + // MockServer does not verify exclusive ownership of the port + // and using any well-known port like 8080 will produce flaky + // test results with fairly confusing errors, like: + // + // path /mockserver/verifySequence was not found + // + // if another webserver is listening to that port. + // We use 0 to let the underlying system find an available port. + mockServer = ClientAndServer.startClientAndServer(0); + noAuthTransport = new DefaultRestTransport( + new RestTransportOptions( + "http", "localhost", mockServer.getLocalPort(), + Collections.emptyMap(), null, null, new Timeout())); + } + + @Test + public void testAuthentication_apiKey() throws Exception { + var authz = Authentication.apiKey("my-api-key"); + var transportOptions = new RestTransportOptions( + "http", "localhost", mockServer.getLocalPort(), + Collections.emptyMap(), authz.getTokenProvider(noAuthTransport), null, new Timeout()); + + try (final var restClient = new DefaultRestTransport(transportOptions)) { + restClient.performRequest(null, SimpleEndpoint.sideEffect( + request -> "GET", request -> "/", request -> null)); + } catch (WeaviateApiException ex) { + if (ex.httpStatusCode() != 404) { + Assertions.fail("unexpected error", ex); + } + } + + mockServer.verify( + HttpRequest.request() + .withMethod("GET") + .withPath("/v1/") + .withHeader("Authorization", "Bearer my-api-key")); + } + + @After + public void stopMockServer() throws Exception { + mockServer.stop(); + noAuthTransport.close(); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/ConfigTest.java b/src/test/java/io/weaviate/client6/v1/api/ConfigTest.java new file mode 100644 index 000000000..b38bef7a1 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/ConfigTest.java @@ -0,0 +1,24 @@ +package io.weaviate.client6.v1.api; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +public class ConfigTest { + + private static final String HEADER_KEY = "X-Weaviate-Client"; + + @Test + public void testHeaderPresence() { + Config config = new Config.Local().build(); + Assertions.assertThat(config.headers()).containsKey(HEADER_KEY); + Assertions.assertThat(config.headers().get(HEADER_KEY)).isNotEmpty(); + + config = new Config.WeaviateCloud("http://localhost/", Authentication.apiKey("test_key")).build(); + Assertions.assertThat(config.headers()).containsKey(HEADER_KEY); + Assertions.assertThat(config.headers().get(HEADER_KEY)).isNotEmpty(); + + config = new Config.Custom().httpHost("localhost").build(); + Assertions.assertThat(config.headers()).containsKey(HEADER_KEY); + Assertions.assertThat(config.headers().get(HEADER_KEY)).isNotEmpty(); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/WeaviateClientAsyncTest.java b/src/test/java/io/weaviate/client6/v1/api/WeaviateClientAsyncTest.java new file mode 100644 index 000000000..085474273 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/WeaviateClientAsyncTest.java @@ -0,0 +1,32 @@ +package io.weaviate.client6.v1.api; + +import org.junit.Test; + +public class WeaviateClientAsyncTest { + + @SuppressWarnings("resource") + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection() { + var config = new Config.Local(); + config.host("localhost").port(1234); + new WeaviateClientAsync(config.build()); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_Local() { + // You might see a warning from gRPC saying that the channel has been + // garbage-collected before it was closed. The stack trace will probably + // show that it's related to this test. + WeaviateClientAsync.connectToLocal(conn -> conn.port(1234)); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_WeaviateCloud() { + WeaviateClientAsync.connectToWeaviateCloud("no-cluster.io", "no-key"); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_Custom() { + WeaviateClient.connectToCustom(conn -> conn.httpHost("localhost").httpPort(1234)); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/WeaviateClientTest.java b/src/test/java/io/weaviate/client6/v1/api/WeaviateClientTest.java new file mode 100644 index 000000000..4563dda95 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/WeaviateClientTest.java @@ -0,0 +1,32 @@ +package io.weaviate.client6.v1.api; + +import org.junit.Test; + +public class WeaviateClientTest { + + @SuppressWarnings("resource") + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection() { + var config = new Config.Local(); + config.host("localhost").port(1234); + new WeaviateClient(config.build()); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_Local() throws Exception { + // You might see a warning from gRPC saying that the channel has been + // garbage-collected before it was closed. The stack trace will probably + // show that it's related to this test. + WeaviateClient.connectToLocal(conn -> conn.port(1234)); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_WeaviateCloud() { + WeaviateClient.connectToWeaviateCloud("no-cluster.io", "no-key"); + } + + @Test(expected = WeaviateConnectException.class) + public void testFailedConnection_Custom() { + WeaviateClient.connectToCustom(conn -> conn.httpHost("localhost").httpPort(1234)); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java new file mode 100644 index 000000000..4b420b3fd --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java @@ -0,0 +1,74 @@ +package io.weaviate.client6.v1.api.collections; + +import java.util.Map; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; + +public class CollectionHandleDefaultsTest { + private static final CollectionDescriptor> DESCRIPTOR = CollectionDescriptor.ofMap("Things"); + private static final CollectionHandleDefaults NONE_DEFAULTS = CollectionHandleDefaults.of(ObjectBuilder.identity()); + + /** CollectionHandle with no defaults. */ + private static final CollectionHandle> HANDLE_NONE = new CollectionHandle<>( + null, null, DESCRIPTOR, NONE_DEFAULTS); + + /** CollectionHandleAsync with no defaults. */ + private static final CollectionHandleAsync> HANDLE_NONE_ASYNC = new CollectionHandleAsync<>( + null, null, DESCRIPTOR, NONE_DEFAULTS); + + /** All defaults are {@code null} if none were set. */ + @Test + public void test_defaults() { + Assertions.assertThat(HANDLE_NONE.consistencyLevel()).as("default ConsistencyLevel").isNull(); + Assertions.assertThat(HANDLE_NONE.tenant()).as("default tenant").isNull(); + } + + /** + * {@link CollectionHandle#withConsistencyLevel} should create a copy with + * different defaults but not modify the original. + */ + @Test + public void test_withConsistencyLevel() { + var handle = HANDLE_NONE.withConsistencyLevel(ConsistencyLevel.QUORUM); + Assertions.assertThat(handle.consistencyLevel()).isEqualTo(ConsistencyLevel.QUORUM); + Assertions.assertThat(HANDLE_NONE.consistencyLevel()).isNull(); + } + + /** + * {@link CollectionHandleAsync#withTenant} should create a copy with + * different defaults but not modify the original. + */ + @Test + public void test_withConsistencyLevel_async() { + var handle = HANDLE_NONE_ASYNC.withConsistencyLevel(ConsistencyLevel.QUORUM); + Assertions.assertThat(handle.consistencyLevel()).isEqualTo(ConsistencyLevel.QUORUM); + Assertions.assertThat(HANDLE_NONE_ASYNC.consistencyLevel()).isNull(); + } + + /** + * {@link CollectionHandle#withTenant} should create a copy with + * different defaults but not modify the original. + */ + @Test + public void test_withTenant() { + var handle = HANDLE_NONE.withTenant("john_doe"); + Assertions.assertThat(handle.tenant()).isEqualTo("john_doe"); + Assertions.assertThat(HANDLE_NONE.consistencyLevel()).isNull(); + } + + /** + * {@link CollectionHandleAsync#withTenant} should create a copy with + * different defaults but not modify the original. + */ + @Test + public void test_withTenant_async() { + var handle = HANDLE_NONE_ASYNC.withTenant("john_doe"); + Assertions.assertThat(handle.tenant()).isEqualTo("john_doe"); + Assertions.assertThat(HANDLE_NONE_ASYNC.consistencyLevel()).isNull(); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java new file mode 100644 index 000000000..9cf1e99d9 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java @@ -0,0 +1,256 @@ +package io.weaviate.client6.v1.api.collections; + +import java.io.IOException; +import java.util.Map; + +import org.assertj.core.api.Assertions; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.google.gson.JsonParser; +import com.jparams.junit4.JParamsTestRunner; +import com.jparams.junit4.data.DataMethod; +import com.jparams.junit4.description.Name; + +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel; +import io.weaviate.client6.v1.internal.ObjectBuilder; +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase; +import io.weaviate.client6.v1.internal.json.JSON; +import io.weaviate.client6.v1.internal.orm.CollectionDescriptor; +import io.weaviate.testutil.transport.MockGrpcTransport; +import io.weaviate.testutil.transport.MockRestTransport; + +@RunWith(JParamsTestRunner.class) +public class CollectionHandleTest { + private static MockRestTransport rest; + private static MockGrpcTransport grpc; + + @BeforeClass + public static void setUp() { + rest = new MockRestTransport(); + grpc = new MockGrpcTransport(); + } + + @AfterClass + public static void tearDown() throws Exception { + rest.close(); + grpc.close(); + } + + @FunctionalInterface + interface Act { + void apply(CollectionHandle> client) throws Exception; + } + + /** Which part of the request a parameter should be added to. */ + public static enum Location { + /** Query string. */ + QUERY, + /** + * Request body. {@code RequestT} must implement {@link WithDefaults} for the + * changes to be applied. + */ + BODY; + } + + public static Object[][] restTestCases() { + return new Object[][] { + { + "data::insert single object", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.BODY, + (Act) c -> c.data.insert(Map.of()), + }, + { + "data::replace single object", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.BODY, + (Act) c -> c.data.replace("test-uuid", ObjectBuilder.identity()), + }, + { + "data::update single object", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.BODY, + (Act) c -> c.data.update("test-uuid", ObjectBuilder.identity()), + }, + { + "data::delete by id", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.QUERY, + (Act) c -> c.data.deleteById("test-uuid"), + }, + { + "data::add reference", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.QUERY, + (Act) c -> c.data.referenceAdd("from-uuid", "from_property", ObjectReference.uuid("to-uuid")), + }, + { + "data::add reference many", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.QUERY, + (Act) c -> c.data.referenceAddMany(), + }, + { + "data::replace reference", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.QUERY, + (Act) c -> c.data.referenceReplace("from-uuid", "from_property", ObjectReference.uuid("to-uuid")), + }, + { + "data::delete reference", + ConsistencyLevel.ONE, Location.QUERY, + "john_doe", Location.QUERY, + (Act) c -> c.data.referenceDelete("from-uuid", "from_property", ObjectReference.uuid("to-uuid")), + }, + }; + } + + @Name("{0}") + @DataMethod(source = CollectionHandleTest.class, method = "restTestCases") + @Test + public void test_collectionHandleDefaults_rest(String __, + ConsistencyLevel cl, Location clLoc, + String tenant, Location tenantLoc, + Act act) + throws Exception { + // Arrange + var collection = CollectionDescriptor.ofMap("Things"); + var defaults = CollectionHandleDefaults.of(d -> d + .consistencyLevel(cl) + .tenant(tenant)); + var client = new CollectionHandle>(rest, grpc, collection, defaults); + + // Act + act.apply(client); + + // Assert + rest.assertNext((method, requestUrl, body, query) -> { + switch (clLoc) { + case QUERY: + Assertions.assertThat(query).containsEntry("consistency_level", defaults.consistencyLevel()); + break; + case BODY: + assertJsonHasValue(body, "consistency_level", defaults.consistencyLevel()); + } + + switch (tenantLoc) { + case QUERY: + Assertions.assertThat(query).containsEntry("tenant", defaults.tenant()); + break; + case BODY: + assertJsonHasValue(body, "tenant", defaults.tenant()); + } + }); + } + + public static Object[][] grpcTestCases() { + return new Object[][] { + { "data::object exists", (Act) c -> c.data.exists("test-uuid") }, + { "data::delete many", (Act) c -> c.data.deleteMany() }, + + { "query::get by id", (Act) c -> c.query.fetchObjectById("test-uuid") }, + { "query::fetch objects", (Act) c -> c.query.fetchObjects(ObjectBuilder.identity()) }, + { "query::bm25", (Act) c -> c.query.bm25("red ballon") }, + { "query::hybrid", (Act) c -> c.query.hybrid("red ballon") }, + { "query::nearVector", (Act) c -> c.query.nearVector(new float[] {}) }, + { "query::nearText", (Act) c -> c.query.nearText("weather in Arizona") }, + { "query::nearObject", (Act) c -> c.query.nearObject("test-uuid") }, + { "query::nearImage", (Act) c -> c.query.nearImage("img.jpeg") }, + { "query::nearAudio", (Act) c -> c.query.nearAudio("song.mp3") }, + { "query::nearVideo", (Act) c -> c.query.nearVideo("clip.mp4") }, + { "query::nearDepth", (Act) c -> c.query.nearDepth("20.000 leagues") }, + { "query::nearThermal", (Act) c -> c.query.nearThermal("Fahrenheit 451") }, + { "query::nearImu", (Act) c -> c.query.nearImu("6 m/s") }, + + { "aggregate::over all", (Act) c -> c.aggregate.overAll(ObjectBuilder.identity()), true }, + { "aggregate::hybrid", (Act) c -> c.aggregate.hybrid("red balloon", ObjectBuilder.identity()), true }, + { "aggregate::nearVector", (Act) c -> c.aggregate.nearVector(new float[] {}, ObjectBuilder.identity()), true }, + { "aggregate::nearText", (Act) c -> c.aggregate.nearText("red balloon", ObjectBuilder.identity()), true }, + { "aggregate::nearObject", (Act) c -> c.aggregate.nearObject("test-uuid", ObjectBuilder.identity()), true }, + { "aggregate::nearImage", (Act) c -> c.aggregate.nearImage("img.jpeg", ObjectBuilder.identity()), true }, + { "aggregate::nearAudio", (Act) c -> c.aggregate.nearAudio("song.mp3", ObjectBuilder.identity()), true }, + { "aggregate::nearVideo", (Act) c -> c.aggregate.nearVideo("clip.mp4", ObjectBuilder.identity()), true }, + { "aggregate::nearDepth", (Act) c -> c.aggregate.nearDepth("20.000 leagues", ObjectBuilder.identity()), true }, + { "aggregate::nearThermal", (Act) c -> c.aggregate.nearThermal("Fahrenheit 451", ObjectBuilder.identity()), + true }, + { "aggregate::nearImu", (Act) c -> c.aggregate.nearImu("6 m/s", ObjectBuilder.identity()), true }, + }; + } + + @Name("{0}") + @DataMethod(source = CollectionHandleTest.class, method = "grpcTestCases") + @Test + public void test_collectionHandleDefaults_grpc(String __, Act act, Boolean skipConsistency) throws Exception { + // Arrange + var collection = CollectionDescriptor.ofMap("Things"); + var defaults = CollectionHandleDefaults.of(d -> d + .consistencyLevel(ConsistencyLevel.ONE) + .tenant("john_doe")); + var client = new CollectionHandle>(rest, grpc, collection, defaults); + + // Act + act.apply(client); + + // Assert + grpc.assertNext(json -> { + assertJsonHasValue(json, "tenant", "john_doe"); + + if (skipConsistency != null && !skipConsistency) { + assertJsonHasValue(json, "consistencyLevel", + WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE.toString()); + } + }); + } + + @Test + public void test_defaultTenant_getShards() throws IOException { + // Arrange + var collection = CollectionDescriptor.ofMap("Things"); + var defaults = CollectionHandleDefaults.of(d -> d + .tenant("john_doe")); + var client = new CollectionHandle>(rest, grpc, collection, defaults); + + // Act + client.config.getShards(); + + // Assert + rest.assertNext((method, requestUrl, body, query) -> { + Assertions.assertThat(query).containsEntry("tenant", defaults.tenant()); + }); + } + + @Test + public void test_defaultTenant_insertMany() { + // Arrange + var collection = CollectionDescriptor.ofMap("Things"); + var defaults = CollectionHandleDefaults.of(d -> d + .consistencyLevel(ConsistencyLevel.ONE) + .tenant("john_doe")); + var client = new CollectionHandle>(rest, grpc, collection, defaults); + + // Act + client.data.insertMany(Map.of()); + + // Assert + grpc.assertNext(json -> { + // Tenant is nested in each of the batch objects + Assertions.assertThat(json).containsSequence("\"tenant\": \"john_doe\""); + assertJsonHasValue(json, "consistencyLevel", + WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE.toString()); + }); + } + + private static void assertJsonHasValue(String json, String key, T value) { + var gotJson = JsonParser.parseString(json).getAsJsonObject(); + Assertions.assertThat(gotJson.has(key)) + .describedAs("missing key \"%s\" in %s", key, json) + .isTrue(); + + var wantValue = JsonParser.parseString(JSON.serialize(value)); + Assertions.assertThat(gotJson.get(key)).isEqualTo(wantValue); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/VectorsTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/VectorsTest.java new file mode 100644 index 000000000..817d79b15 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/collections/VectorsTest.java @@ -0,0 +1,29 @@ +package io.weaviate.client6.v1.api.collections; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +public class VectorsTest { + @Test + public void testToString_1d() { + var vector = Vectors.of(new float[] { 1, 2, 3 }); + var got = vector.toString(); + Assertions.assertThat(got).isEqualTo("Vectors(default=[1.0, 2.0, 3.0])"); + } + + @Test + public void testToString_2d() { + var vector = Vectors.of(new float[][] { { 1, 2, 3 }, { 1, 2, 3 } }); + var got = vector.toString(); + Assertions.assertThat(got).isEqualTo("Vectors(default=[[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]])"); + } + + @Test + public void testToString_multiple() { + var title = Vectors.of("title", new float[] { 1, 2, 3 }); + var body = Vectors.of("body", new float[][] { { 1, 2, 3 }, { 1, 2, 3 } }); + var vectors = new Vectors(title, body); + var got = vectors.toString(); + Assertions.assertThat(got).isEqualTo("Vectors(title=[1.0, 2.0, 3.0], body=[[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]])"); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/query/TargetTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/query/TargetTest.java new file mode 100644 index 000000000..92ed061e3 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/api/collections/query/TargetTest.java @@ -0,0 +1,245 @@ +package io.weaviate.client6.v1.api.collections.query; + +import org.assertj.core.api.Assertions; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.google.gson.JsonParser; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.MessageOrBuilder; +import com.google.protobuf.util.JsonFormat; +import com.jparams.junit4.JParamsTestRunner; +import com.jparams.junit4.data.DataMethod; + +import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch; + +@RunWith(JParamsTestRunner.class) +public class TargetTest { + + public static Object[][] appendTargetsTestCases() { + return new Object[][] { + { + Target.vector(new float[] { 1, 2, 3 }), + null, + }, + { + Target.vector("title_vec", new float[] { 1, 2, 3 }), + """ + { "targetVectors": ["title_vec"] } + """, + }, + { + Target.text("title_vec", "one", "two"), + """ + { "targetVectors": ["title_vec"] } + """, + }, + { + Target.average( + Target.vector("title_vec", new float[] { 1, 2, 3 }), + Target.vector("body_vec", new float[] { 4, 5, 6 })), + """ + { + "combination": "COMBINATION_METHOD_TYPE_AVERAGE", + "targetVectors": ["title_vec", "body_vec"] + } + """, + + }, + { + Target.manualWeights( + Target.vector("title_vec", .2f, new float[] { 1, 2, 3 }), + Target.vector("title_vec", .3f, new float[] { 1, 2, 3 }), + Target.vector("body_vec", .5f, new float[] { 4, 5, 6 })), + """ + { + "combination": "COMBINATION_METHOD_TYPE_MANUAL", + "targetVectors": ["title_vec", "title_vec", "body_vec"], + "weightsForTargets": [ + {"target": "title_vec", "weight": 0.2}, + {"target": "title_vec", "weight": 0.3}, + {"target": "body_vec", "weight": 0.5} + ] + } + """, + + }, + { + Target.min( + "in the summertime", + "title_vec", "body_vec"), + """ + { + "combination": "COMBINATION_METHOD_TYPE_MIN", + "targetVectors": ["title_vec", "body_vec"] + } + """, + + }, + { + Target.relativeScore( + "one and two and three and four", + Target.weight("title_vec", 2), + Target.weight("body_vec", 3)), + """ + { + "combination": "COMBINATION_METHOD_TYPE_RELATIVE_SCORE", + "targetVectors": ["title_vec", "body_vec"], + "weightsForTargets": [ + {"target": "title_vec", "weight": 2.0}, + {"target": "body_vec", "weight": 3.0} + ] + } + """, + + }, + }; + } + + @Test + @DataMethod(source = TargetTest.class, method = "appendTargetsTestCases") + public void test_appendTargets(Target target, String want) { + var req = WeaviateProtoBaseSearch.Targets.newBuilder(); + var appended = target.appendTargets(req); + if (want == null) { + Assertions.assertThat(appended).as("should not append targets").isFalse(); + return; + } + + var got = proto2json(req); + assertEqualJson(want, got); + } + + public static Object[][] appendVectorsTestCases() { + return new Object[][] { + { + Target.vector(new float[] { 1, 2, 3 }), + """ + { + "vectors": [{ + "vectorBytes": "AACAPwAAAEAAAEBA", + "type": "VECTOR_TYPE_SINGLE_FP32" + }] + } + """, + }, + { + Target.vector(new float[][] { { 1, 2, 3 }, { 4, 5, 6 } }), + """ + { + "vectors": [{ + "vectorBytes": "AwAAAIA/AAAAQAAAQEAAAIBAAACgQAAAwEA=", + "type": "VECTOR_TYPE_MULTI_FP32" + }] + } + """, + }, + { + Target.vector("title_vec", new float[] { 1, 2, 3 }), + """ + { + "vectorForTargets": [{ + "name": "title_vec", + "vectors": [{ + "vectorBytes": "AACAPwAAAEAAAEBA", + "type": "VECTOR_TYPE_SINGLE_FP32" + }] + }] + } + """, + }, + { + Target.vector("title_vec", new float[][] { { 1, 2, 3 }, { 4, 5, 6 } }), + """ + { + "vectorForTargets": [{ + "name": "title_vec", + "vectors": [{ + "vectorBytes": "AwAAAIA/AAAAQAAAQEAAAIBAAACgQAAAwEA=", + "type": "VECTOR_TYPE_MULTI_FP32" + }] + }] + } + """, + }, + { + Target.average( + Target.vector("title_vec", new float[] { 1, 2, 3 }), + Target.vector("title_vec", new float[] { 4, 5, 6 }), + Target.vector("lyrics_vec", new float[] { 7, 8, 9 })), + """ + { + "vectorForTargets": [ + { + "name": "title_vec", + "vectors": [ + {"vectorBytes": "AACAPwAAAEAAAEBA", "type": "VECTOR_TYPE_SINGLE_FP32" }, + {"vectorBytes": "AACAQAAAoEAAAMBA", "type": "VECTOR_TYPE_SINGLE_FP32" } + ] + }, + { + "name": "lyrics_vec", + "vectors": [ + {"vectorBytes": "AADgQAAAAEEAABBB", "type": "VECTOR_TYPE_SINGLE_FP32" } + ] + } + ] + } + """, + }, + { + Target.average( + Target.vector("title_vec", new float[][] { { 1, 2, 3 }, { 4, 5, 6 } }), + Target.vector("title_vec", new float[][] { { 4, 5, 6 }, { 7, 8, 9 } }), + Target.vector("lyrics_vec", new float[][] { { 7, 8, 9 }, { 1, 2, 3 } })), + """ + { + "vectorForTargets": [ + { + "name": "title_vec", + "vectors": [ + {"vectorBytes": "AwAAAIA/AAAAQAAAQEAAAIBAAACgQAAAwEA=", "type": "VECTOR_TYPE_MULTI_FP32" }, + {"vectorBytes": "AwAAAIBAAACgQAAAwEAAAOBAAAAAQQAAEEE=", "type": "VECTOR_TYPE_MULTI_FP32" } + ] + }, + { + "name": "lyrics_vec", + "vectors": [ + {"vectorBytes": "AwAAAOBAAAAAQQAAEEEAAIA/AAAAQAAAQEA=", "type": "VECTOR_TYPE_MULTI_FP32" } + ] + } + ] + } + """, + }, + }; + } + + @Test + @DataMethod(source = TargetTest.class, method = "appendVectorsTestCases") + public void test_appendVectors(NearVectorTarget target, String want) { + var req = WeaviateProtoBaseSearch.NearVector.newBuilder(); + + target.appendVectors(req); + + var got = proto2json(req); + assertEqualJson(want, got); + } + + private static final String proto2json(MessageOrBuilder proto) { + String out; + try { + out = JsonFormat.printer().print(proto); + } catch (InvalidProtocolBufferException e) { + out = e.getMessage(); + } + + return out; + } + + private static void assertEqualJson(String want, String got) { + var wantJson = JsonParser.parseString(want); + var gotJson = JsonParser.parseString(got); + Assertions.assertThat(gotJson).isEqualTo(wantJson); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/BuildInfoTest.java b/src/test/java/io/weaviate/client6/v1/internal/BuildInfoTest.java new file mode 100644 index 000000000..dded492c7 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/BuildInfoTest.java @@ -0,0 +1,53 @@ +package io.weaviate.client6.v1.internal; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +import org.assertj.core.api.Assertions; +import org.junit.Assume; +import org.junit.Test; + +public class BuildInfoTest { + private static final String BRANCH = gitBranch(); + private static final String COMMIT_ID = gitCommit(); + private static final String TAGS = gitTags(); + + @Test + public void testBuildInfo() throws IOException { + Assume.assumeNotNull(BRANCH, COMMIT_ID); + Assume.assumeTrue("found git branch", !BRANCH.isBlank()); + Assume.assumeTrue("found git commit", !COMMIT_ID.isBlank()); + + Assertions.assertThat(BuildInfo.BRANCH).as("branch").isEqualTo(BRANCH); + Assertions.assertThat(BuildInfo.COMMIT_ID).as("commit.full").isEqualTo(COMMIT_ID); + Assertions.assertThat(COMMIT_ID).as("commit.abbrev").startsWith(BuildInfo.COMMIT_ID_ABBREV); + Assertions.assertThat(BuildInfo.TAGS).as("tags").isEqualTo(TAGS); + } + + /** Get current non-abbreviated Git commit hash. */ + private static String gitCommit() { + return runCommand("/usr/bin/git", "rev-parse", "HEAD"); + } + + /** Get current git branch. */ + private static String gitBranch() { + return runCommand("/usr/bin/git", "branch", "--show-current"); + } + + /** Get current git tags. */ + private static String gitTags() { + return runCommand("/usr/bin/git", "tag", "--points-at", "HEAD"); + } + + /** Run shell command and return the output as multi-line string. */ + private static String runCommand(String... cmdarray) { + try { + var process = Runtime.getRuntime().exec(cmdarray); + var r = new BufferedReader(new InputStreamReader(process.getInputStream())); + return String.join("\n", (Iterable) () -> r.lines().iterator()); + } catch (IOException e) { + return null; + } + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/TokenTest.java b/src/test/java/io/weaviate/client6/v1/internal/TokenTest.java new file mode 100644 index 000000000..789ffca1a --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/TokenTest.java @@ -0,0 +1,43 @@ +package io.weaviate.client6.v1.internal; + +import java.time.Instant; + +import org.assertj.core.api.Assertions; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.jparams.junit4.JParamsTestRunner; +import com.jparams.junit4.data.DataMethod; + +import io.weaviate.client6.v1.internal.TokenProvider.Token; + +@RunWith(JParamsTestRunner.class) +public class TokenTest { + + public static Object[][] testCaseTokens() { + return new Object[][] { + { Token.expireNever("access_token"), true }, + { Token.expireAfter("access_token", "refresh_token", 100), true }, + { Token.expireAfter("access_token", 100), true }, + { new Token("access_token", "refresh_token", Instant.now().minusSeconds(10), 5, 0), false }, + { Token.expireAfter("access_token", 0), false }, + { Token.expireAfter("access_token", 5).withExpiryDelta(10), false }, + { Token.expireAfter("access_token", 100).withExpiryDelta(10), true }, + }; + } + + @DataMethod(source = TokenTest.class, method = "testCaseTokens") + @Test + public void test_isValid(Token token, boolean wantValid) { + Assertions.assertThat(token.isValid()) + .as(token.toString()) + .isEqualTo(wantValid); + } + + @Test + public void test_expiryDeltaNonNegative() { + var t = Token.expireAfter("access_token", 90L); + var expireLater = t.withExpiryDelta(-10L); + Assertions.assertThat(expireLater.expiryDelta()).as("expiryDelta must be >= 0").isEqualTo(0L); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/VersionSupportTest.java b/src/test/java/io/weaviate/client6/v1/internal/VersionSupportTest.java new file mode 100644 index 000000000..e735f6738 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/VersionSupportTest.java @@ -0,0 +1,40 @@ +package io.weaviate.client6.v1.internal; + +import org.assertj.core.api.Assertions; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.jparams.junit4.JParamsTestRunner; +import com.jparams.junit4.data.DataMethod; + +import io.weaviate.client6.v1.internal.VersionSupport.SemanticVersion; + +@RunWith(JParamsTestRunner.class) +public class VersionSupportTest { + public static Object[][] testCases() { + return new Object[][] { + { "1.31.6", "v1.32.1", true }, // can have a leading v + { "v1.33.0", "1.32.1", false }, // can have a leading v + { "2.36.2", "2.36.0-rc.3", true }, // patch ignored + { "1.12", "1.11", false }, // omit patch + { "0.55.6", "0.1.0", false }, // can start with zero + }; + } + + @Test + @DataMethod(source = VersionSupportTest.class, method = "testCases") + public void test_isSupported(String minimal, String actual, boolean isSupported) { + var v_minimal = SemanticVersion.of(minimal); + var v_actual = SemanticVersion.of(actual); + + if (isSupported) { + Assertions.assertThat(v_actual) + .describedAs("%s supported (minimal=%s)", actual, minimal) + .isGreaterThanOrEqualTo(v_minimal); + } else { + Assertions.assertThat(v_actual) + .describedAs("%s not supported (minimal=%s)", actual, minimal) + .isLessThan(v_minimal); + } + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtilTest.java b/src/test/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtilTest.java new file mode 100644 index 000000000..6d7b3abe8 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/grpc/ByteStringUtilTest.java @@ -0,0 +1,129 @@ +package io.weaviate.client6.v1.internal.grpc; + +import org.assertj.core.api.Assertions; +import org.junit.Test; + +import com.google.protobuf.ByteString; + +/** + * Note: Java's {@code byte} is signed (int8) and is different from {@code byte} + * in Go, which is an alias for uint8. + * + * For this tests purposes the distinction is immaterial, as "want" arrays + * are "golden values" meant to be a readable respresentation for the test. + */ +public class ByteStringUtilTest { + @Test + public void test_encodeVector_1d() { + float[] vector = { 1f, 2f, 3f }; + byte[] want = { 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64 }; + byte[] got = ByteStringUtil.encodeVectorSingle(vector).toByteArray(); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_decodeVector_1d() { + byte[] bytes = { 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64 }; + float[] want = { 1f, 2f, 3f }; + float[] got = ByteStringUtil.decodeVectorSingle(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_encodeVector_2d() { + float[][] vector = { { 1f, 2f, 3f }, { 4f, 5f, 6f } }; + byte[] want = { 3, 0, 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64, 0, 0, -96, 64, 0, 0, -64, 64 }; + byte[] got = ByteStringUtil.encodeVectorMulti(vector).toByteArray(); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_decodeVector_2d() { + byte[] bytes = { 3, 0, 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64, 0, 0, -96, 64, 0, 0, -64, 64 }; + float[][] want = { { 1f, 2f, 3f }, { 4f, 5f, 6f } }; + float[][] got = ByteStringUtil.decodeVectorMulti(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_decodeUuid() { + byte[] bytes = { 38, 19, -74, 24, -114, -19, 73, 43, -112, -60, 47, 96, 83, -89, -35, -23 }; + String want = "2613b618-8eed-492b-90c4-2f6053a7dde9"; + String got = ByteStringUtil.decodeUuid(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_decodeUuid_bufferUnderflow() { + byte[] bytes = { 38, 19 }; // A valid UUID is exactly 16 bytes + String got = ByteStringUtil.decodeUuid(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isNull(); + } + + @Test + public void test_decodeVector_1d_empty() { + byte[] bytes = new byte[0]; + float[] got = ByteStringUtil.decodeVectorSingle(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEmpty(); + } + + @Test + public void test_decodeVector_2d_empty() { + byte[] bytes = new byte[0]; + float[][] got = ByteStringUtil.decodeVectorMulti(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEmpty(); + } + + @Test + public void test_decodeVector_2d_dim_zero() { + byte[] bytes = { 0, 0 }; + float[][] got = ByteStringUtil.decodeVectorMulti(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEmpty(); + } + + @Test + public void test_decodeIntValues() { + byte[] bytes = { 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0 }; + long[] want = { 1, 2, 3 }; + long[] got = ByteStringUtil.decodeIntValues(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test + public void test_decodeNumberValues() { + byte[] bytes = { 0, 0, 0, 0, 0, 0, -16, 63, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 8, 64 }; + double[] want = { 1, 2, 3 }; + double[] got = ByteStringUtil.decodeNumberValues(ByteString.copyFrom(bytes)); + Assertions.assertThat(got).isEqualTo(want); + } + + @Test(expected = IllegalArgumentException.class) + public void test_decodeVector_1d_illegal() { + byte[] bytes = new byte[Float.BYTES - 1]; // must be a multiple of Float.BYTES + ByteStringUtil.decodeVectorSingle(ByteString.copyFrom(bytes)); + } + + @Test(expected = IllegalArgumentException.class) + public void test_decodeVector_2d_illegal() { + // The first Short.BYTES is the dimensionality of each array. + // The size of the rest must be a multiple of Float.BYTES * dimensionality. + var dimensionality = 5; + byte[] bytes = new byte[Short.BYTES + (Float.BYTES * dimensionality - 1)]; + bytes[0] = 0; + bytes[1] = (byte) dimensionality; + + ByteStringUtil.decodeVectorMulti(ByteString.copyFrom(bytes)); + } + + @Test(expected = IllegalArgumentException.class) + public void test_decodeIntValues_illegal() { + byte[] bytes = new byte[Long.BYTES - 1]; // must be a multiple of Long.BYTES + ByteStringUtil.decodeIntValues(ByteString.copyFrom(bytes)); + } + + @Test(expected = IllegalArgumentException.class) + public void test_decodeNumberValues_illegal() { + byte[] bytes = new byte[Double.BYTES - 1]; // must be a multiple of Double.BYTES + ByteStringUtil.decodeNumberValues(ByteString.copyFrom(bytes)); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java b/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java new file mode 100644 index 000000000..7dee98b08 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java @@ -0,0 +1,2176 @@ +package io.weaviate.client6.v1.internal.json; + +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2MultiVecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecAwsVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecCohereVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecGoogleVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecNvidiaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecVoyageAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecAwsVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecAzureOpenAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecDatabricksVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecGoogleVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecHuggingFaceVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecJinaAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecMistralVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecModel2VecVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecMorphVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecNvidiaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecOllamaVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecOpenAiVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecTransformersVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecVoyageAiVectorizer; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.function.BiConsumer; + +import org.assertj.core.api.Assertions; +import org.junit.Test; +import org.junit.runner.RunWith; + +import com.google.gson.JsonParser; +import com.google.gson.reflect.TypeToken; +import com.jparams.junit4.JParamsTestRunner; +import com.jparams.junit4.data.DataMethod; + +import io.weaviate.client6.v1.api.cluster.NodeVerbosity; +import io.weaviate.client6.v1.api.collections.CollectionConfig; +import io.weaviate.client6.v1.api.collections.Encoding; +import io.weaviate.client6.v1.api.collections.Generative; +import io.weaviate.client6.v1.api.collections.Property; +import io.weaviate.client6.v1.api.collections.Quantization; +import io.weaviate.client6.v1.api.collections.ReferenceProperty; +import io.weaviate.client6.v1.api.collections.Reranker; +import io.weaviate.client6.v1.api.collections.Tokenization; +import io.weaviate.client6.v1.api.collections.VectorConfig; +import io.weaviate.client6.v1.api.collections.Vectors; +import io.weaviate.client6.v1.api.collections.WeaviateObject; +import io.weaviate.client6.v1.api.collections.data.BatchReference; +import io.weaviate.client6.v1.api.collections.data.ObjectReference; +import io.weaviate.client6.v1.api.collections.data.ReferenceAddManyResponse; +import io.weaviate.client6.v1.api.collections.quantizers.PQ; +import io.weaviate.client6.v1.api.collections.rerankers.CohereReranker; +import io.weaviate.client6.v1.api.collections.vectorindex.Distance; +import io.weaviate.client6.v1.api.collections.vectorindex.Dynamic; +import io.weaviate.client6.v1.api.collections.vectorindex.Flat; +import io.weaviate.client6.v1.api.collections.vectorindex.Hnsw; +import io.weaviate.client6.v1.api.collections.vectorindex.MultiVector; +import io.weaviate.client6.v1.api.collections.vectorindex.MultiVector.Aggregation; +import io.weaviate.client6.v1.api.collections.vectorizers.Img2VecNeuralVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Multi2VecClipVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.SelfProvidedVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecCohereVectorizer; +import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecWeaviateVectorizer; +import io.weaviate.client6.v1.api.rbac.AliasesPermission; +import io.weaviate.client6.v1.api.rbac.BackupsPermission; +import io.weaviate.client6.v1.api.rbac.ClusterPermission; +import io.weaviate.client6.v1.api.rbac.CollectionsPermission; +import io.weaviate.client6.v1.api.rbac.DataPermission; +import io.weaviate.client6.v1.api.rbac.GroupsPermission; +import io.weaviate.client6.v1.api.rbac.NodesPermission; +import io.weaviate.client6.v1.api.rbac.ReplicatePermission; +import io.weaviate.client6.v1.api.rbac.Role; +import io.weaviate.client6.v1.api.rbac.RolesPermission; +import io.weaviate.client6.v1.api.rbac.RolesPermission.Scope; +import io.weaviate.client6.v1.api.rbac.TenantsPermission; +import io.weaviate.client6.v1.api.rbac.UsersPermission; +import io.weaviate.client6.v1.api.rbac.groups.GroupType; + +/** Unit tests for custom POJO-to-JSON serialization. */ +@RunWith(JParamsTestRunner.class) +public class JSONTest { + public static Object[][] testCases() { + return new Object[][] { + // Vectorizer.CustomTypeAdapterFactory + { + VectorConfig.class, + SelfProvidedVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": {"none": {}} + } + """, + }, + { + VectorConfig.class, + Img2VecNeuralVectorizer.of(i2v -> i2v.imageFields("jpeg", "png")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "img2vec-neural": { + "imageFields": ["jpeg", "png"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecClipVectorizer.of(m2v -> m2v + .inferenceUrl("http://example.com") + .imageField("img", 1f) + .textField("txt", 2f)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-clip": { + "inferenceUrl": "http://example.com", + "imageFields": ["img"], + "textFields": ["txt"], + "weights": { + "imageWeights": [1.0], + "textWeights": [2.0] + } + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecCohereVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-cohere": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecCohereVectorizer.of( + v -> v.sourceProperties("a").model("embed-v4.0") + ), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-cohere": { + "model": "embed-v4.0", + "vectorizeClassName": false, + "properties": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecAwsVectorizer.bedrock("amazon.titan-embed-text-v2:0"), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-aws": { + "service": "bedrock", + "model": "amazon.titan-embed-text-v2:0", + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecDatabricksVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-databricks": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecDatabricksVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-databricks": { + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecGoogleVectorizer.vertex("projectId", v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-google": { + "apiEndpoint":"us-central1-aiplatform.googleapis.com", + "projectId": "projectId", + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecGoogleVectorizer.aiStudio(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-google": { + "apiEndpoint":"generativelanguage.googleapis.com", + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecHuggingFaceVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-huggingface": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecHuggingFaceVectorizer.of(v -> v.sourceProperties("a").model("model")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-huggingface": { + "model": "model", + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecJinaAiVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-jinaai": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecJinaAiVectorizer.of(v -> v.sourceProperties("a").model(Text2VecJinaAiVectorizer.JINA_EMBEDDINGS_V2_BASE_EN)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-jinaai": { + "model": "jina-embeddings-v2-base-en", + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecMistralVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-mistral": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecMistralVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-mistral": { + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecModel2VecVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-model2vec": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecModel2VecVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-model2vec": { + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecMorphVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-morph": {} + } + } + """, + }, + { + VectorConfig.class, + Text2VecMorphVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-morph": { + "properties": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecNvidiaVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-nvidia": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecNvidiaVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-nvidia": { + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecOllamaVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-ollama": { + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecOllamaVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-ollama": { + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecOpenAiVectorizer.of(v -> v.sourceProperties("a").model(Text2VecOpenAiVectorizer.TEXT_EMBEDDING_3_LARGE)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-openai": { + "model": "text-embedding-3-large", + "properties": ["a"], + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecTransformersVectorizer.of(), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-transformers": {} + } + } + """, + }, + { + VectorConfig.class, + Text2VecVoyageAiVectorizer.of(v -> v.sourceProperties("a").model(Text2VecVoyageAiVectorizer.VOYAGE_3_LARGE)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-voyageai": { + "model": "voyage-3-large", + "properties": ["a"], + "vectorizeClassName":false + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecTransformersVectorizer.of(v -> v.sourceProperties("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-transformers": { + "properties": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecWeaviateVectorizer.of(t2v -> t2v + .baseUrl("http://example.com") + .dimensions(4) + .model("very-good-model")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-weaviate": { + "baseURL": "http://example.com", + "dimensions": 4, + "model": "very-good-model" + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecOpenAiVectorizer.of(v -> v.sourceProperties("a", "b")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-openai": { + "vectorizeClassName": false, + "properties": ["a", "b"] + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecVoyageAiVectorizer.of(v -> + v.sourceProperties(List.of("a", "b", "c")).model("voyage-3-large")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-voyageai": { + "model": "voyage-3-large", + "vectorizeClassName": false, + "properties": ["a", "b", "c"] + } + } + } + """, + }, + { + VectorConfig.class, + Text2VecVoyageAiVectorizer.of(v -> + v.dimensions(256).model("voyage-3-large")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "text2vec-voyageai": { + "model": "voyage-3-large", + "dimensions": 256, + "vectorizeClassName": false + } + } + } + """, + }, + { + VectorConfig.class, + Img2VecNeuralVectorizer.of(v -> v.imageFields("a", "b")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "img2vec-neural": { + "imageFields": ["a", "b"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2MultiVecJinaAiVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2multivec-jinaai": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecClipVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-clip": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecClipVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-clip": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecClipVectorizer.of(v -> v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-clip": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecAwsVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-aws": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecAwsVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-aws": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecAwsVectorizer.of(v -> v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-aws": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecCohereVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-cohere": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecCohereVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-cohere": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecCohereVectorizer.of(v -> v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f)), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-cohere": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecGoogleVectorizer.of("project-id", "location", v -> v.imageFields("a", "b").textFields("c").videoFields("d")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-google": { + "projectId": "project-id", + "location": "location", + "imageFields": ["a", "b"], + "textFields": ["c"], + "videoFields": ["d"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecGoogleVectorizer.of("project-id", "location", v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-google": { + "projectId": "project-id", + "location": "location", + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecGoogleVectorizer.of("project-id", "location",v -> + v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f).videoField("d", 0.99f) + ), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-google": { + "projectId": "project-id", + "location": "location", + "imageFields": ["a", "b"], + "textFields": ["c"], + "videoFields": ["d"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8], + "videoWeights":[0.99] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecJinaAiVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-jinaai": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecJinaAiVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-jinaai": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecJinaAiVectorizer.of(v -> + v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f) + ), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-jinaai": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecNvidiaVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-nvidia": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecNvidiaVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-nvidia": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecNvidiaVectorizer.of(v -> + v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f) + ), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-nvidia": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecVoyageAiVectorizer.of(v -> v.imageFields("a", "b").textFields("c")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-voyageai": { + "imageFields": ["a", "b"], + "textFields": ["c"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecVoyageAiVectorizer.of(v -> v.imageFields("a")), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-voyageai": { + "imageFields": ["a"] + } + } + } + """, + }, + { + VectorConfig.class, + Multi2VecVoyageAiVectorizer.of(v -> + v.imageField("a", 0.1f).imageField("b", 0.1f).textField("c", 0.8f) + ), + """ + { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": { + "multi2vec-voyageai": { + "imageFields": ["a", "b"], + "textFields": ["c"], + "weights":{ + "imageWeights":[0.1,0.1], + "textWeights":[0.8] + } + } + } + } + """, + }, + + // VectorIndex.CustomTypeAdapterFactory + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .vectorIndex(Flat.of(flat -> flat + .vectorCacheMaxObjects(100)))), + """ + { + "vectorIndexType": "flat", + "vectorizer": {"none": {}}, + "vectorIndexConfig": {"vectorCacheMaxObjects": 100} + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .vectorIndex(Dynamic.of(idx -> idx + .hnsw(Hnsw.of(hnsw -> hnsw + .ef(1) + .efConstruction(2))) + .flat(Flat.of(flat -> flat + .vectorCacheMaxObjects(100))) + .threshold(5)))), + """ + { + "vectorIndexType": "dynamic", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "flat": {"vectorCacheMaxObjects": 100}, + "hnsw": {"ef": 1, "efConstruction": 2}, + "threshold": 5 + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .quantization(Quantization.pq(pq -> pq + .centroids(8) + .encoderDistribution(PQ.EncoderDistribution.NORMAL) + .encoderType(PQ.EncoderType.TILE) + .segments(16) + .trainingLimit(1024) + .bitCompression(true)))), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "pq": { + "enabled": true, + "centroids": 8, + "encoder_distribution": "normal", + "encoder_type": "tile", + "segments": 16, + "training_limit": 1024, + "bit_compression": true + } + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .quantization(Quantization.sq(sq -> sq + .rescoreLimit(10) + .trainingLimit(1024) + .cache(true)))), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "sq": { + "enabled": true, + "rescore_limit": 10, + "training_limit": 1024, + "cache": true + } + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .quantization(Quantization.rq(rq -> rq + .rescoreLimit(10) + .bits(8)))), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "rq": { + "enabled": true, + "rescore_limit": 10, + "bits": 8 + } + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .quantization(Quantization.bq(bq -> bq + .rescoreLimit(10) + .cache(true)))), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "bq": { + "enabled": true, + "rescore_limit": 10, + "cache": true + } + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .quantization(Quantization.uncompressed())), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "skipDefaultQuantization": true + } + } + """, + }, + { + VectorConfig.class, + SelfProvidedVectorizer.of(none -> none + .vectorIndex(Hnsw.of(hnsw -> hnsw + .distance(Distance.DOT) + .ef(1) + .efConstruction(2) + .maxConnections(3) + .vectorCacheMaxObjects(4) + .cleanupIntervalSeconds(5) + .dynamicEfMin(6) + .dynamicEfMax(7) + .dynamicEfFactor(8) + .flatSearchCutoff(9) + .skipVectorization(true) + .filterStrategy(Hnsw.FilterStrategy.ACORN)))), + """ + { + "vectorIndexType": "hnsw", + "vectorizer": {"none": {}}, + "vectorIndexConfig": { + "distance": "dot", + "ef": 1, + "efConstruction": 2, + "maxConnections": 3, + "vectorCacheMaxObjects": 4, + "cleanupIntervalSeconds": 5, + "dynamicEfMin": 6, + "dynamicEfMax": 7, + "dynamicEfFactor": 8, + "flatSearchCutoff": 9, + "skip": true, + "filterStrategy":"acorn" + } + } + """, + }, + + // Vectors.CustomTypeAdapterFactory + { + Vectors.class, + Vectors.of(new float[] { 1f, 2f }), + "{\"default\": [1.0, 2.0]}", + (CustomAssert) JSONTest::compareVectors, + }, + { + Vectors.class, + Vectors.of(new float[][] { { 1f, 2f }, { 3f, 4f } }), + "{\"default\": [[1.0, 2.0], [3.0, 4.0]]}", + (CustomAssert) JSONTest::compareVectors, + }, + { + Vectors.class, + Vectors.of("custom", new float[] { 1f, 2f }), + "{\"custom\": [1.0, 2.0]}", + (CustomAssert) JSONTest::compareVectors, + }, + { + Vectors.class, + Vectors.of("custom", new float[][] { { 1f, 2f }, { 3f, 4f } }), + "{\"custom\": [[1.0, 2.0], [3.0, 4.0]]}", + (CustomAssert) JSONTest::compareVectors, + }, + { + Vectors.class, + new Vectors( + Vectors.of("1d", new float[] { 1f, 2f }), + Vectors.of("2d", new float[][] { { 1f, 2f }, { 3f, 4f } })), + "{\"1d\": [1.0, 2.0], \"2d\": [[1.0, 2.0], [3.0, 4.0]]}", + (CustomAssert) JSONTest::compareVectors, + }, + + // WeaviateCollection.CustomTypeAdapterFactory + { + CollectionConfig.class, + CollectionConfig.of("Things", things -> things + .description("A collection of things") + .properties( + Property.text("shape"), + Property.text("custom_id", p -> p.tokenization(Tokenization.WORD)), + Property.integer("size")) + .references( + ReferenceProperty.to("owner", "Person", "Company")) + .vectorConfig( + VectorConfig.img2vecNeural("v-shape", + i2v -> i2v.imageFields("img")))), + """ + { + "class": "Things", + "description": "A collection of things", + "properties": [ + {"name": "shape", "dataType": ["text"]}, + {"name": "size", "dataType": ["int"]}, + {"name": "custom_id", "dataType": ["text"], tokenization: "word"}, + {"name": "owner", "dataType": ["Person", "Company"]} + ], + "vectorConfig": { + "v-shape": { + "vectorIndexType": "hnsw", + "vectorIndexConfig": {}, + "vectorizer": {"img2vec-neural": { + "imageFields": ["img"] + }} + } + } + } + """, + }, + + // Reference.TYPE_ADAPTER + { + ObjectReference.class, + ObjectReference.uuid("id-1"), + "{\"beacon\": \"weaviate://localhost/id-1\"}", + }, + { + ObjectReference.class, + ObjectReference.collection("Doodlebops", "id-1"), + "{\"beacon\": \"weaviate://localhost/Doodlebops/id-1\"}", + }, + + // WriteWeaviateObject.CustomTypeAdapterFactory.INSTANCE + { + new TypeToken>>() { + }, + new WeaviateObject<>( + "thing-1", + "Things", + /* tenant */ null, + Map.of("title", "ThingOne"), + /* vectors */ null, + /* creationTimeUnix */ null, + /* lastUpdateTimeUnix */ null, + /* queryMetadata */ null, + Map.of("hasRef", List.of(ObjectReference.uuid("ref-1")))), + + """ + { + "class": "Things", + "properties": { + "title": "ThingOne", + "hasRef": [{"beacon": "weaviate://localhost/ref-1"}] + }, + "id": "thing-1" + } + """, + }, + + // Reranker.CustomTypeAdapterFactory + { + Reranker.class, + Reranker.cohere(rerank -> rerank + .model(CohereReranker.RERANK_ENGLISH_V2)), + """ + { + "reranker-cohere": { + "model": "rerank-english-v2.0" + } + } + """, + }, + + // BatchReference.CustomTypeAdapterFactory + { + BatchReference.class, + new BatchReference("FromCollection", "fromProperty", "from-uuid", + ObjectReference.collection("ToCollection", "to-uuid")), + """ + { + "from": "weaviate://localhost/FromCollection/from-uuid/fromProperty", + "to": "weaviate://localhost/ToCollection/to-uuid" + } + """, + }, + + // Role.CustomTypeAdapterFactory & Permission.CustomTypeAdapterFactory + { + Role.class, + new Role( + "rock-n-role", + List.of( + new AliasesPermission( + "CollectionAlias", + "Collection", + List.of( + AliasesPermission.Action.CREATE, + AliasesPermission.Action.READ, + AliasesPermission.Action.UPDATE, + AliasesPermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_aliases", + "aliases": { + "alias": "CollectionAlias", + "collection": "Collection" + } + }, + { + "action": "read_aliases", + "aliases": { + "alias": "CollectionAlias", + "collection": "Collection" + } + }, + { + "action": "update_aliases", + "aliases": { + "alias": "CollectionAlias", + "collection": "Collection" + } + }, + { + "action": "delete_aliases", + "aliases": { + "alias": "CollectionAlias", + "collection": "Collection" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new BackupsPermission( + "Collection", + List.of(BackupsPermission.Action.MANAGE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "manage_backups", + "backups": { + "collection": "Collection" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new ClusterPermission( + List.of(ClusterPermission.Action.READ)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { "action": "read_cluster" } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new CollectionsPermission( + "Collection", + List.of( + CollectionsPermission.Action.CREATE, + CollectionsPermission.Action.READ, + CollectionsPermission.Action.UPDATE, + CollectionsPermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_collections", + "collections": { + "collection": "Collection" + } + }, + { + "action": "read_collections", + "collections": { + "collection": "Collection" + } + }, + { + "action": "update_collections", + "collections": { + "collection": "Collection" + } + }, + { + "action": "delete_collections", + "collections": { + "collection": "Collection" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new DataPermission( + "Collection", + List.of( + DataPermission.Action.CREATE, + DataPermission.Action.READ, + DataPermission.Action.UPDATE, + DataPermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_data", + "data": { + "collection": "Collection" + } + }, + { + "action": "read_data", + "data": { + "collection": "Collection" + } + }, + { + "action": "update_data", + "data": { + "collection": "Collection" + } + }, + { + "action": "delete_data", + "data": { + "collection": "Collection" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new GroupsPermission( + "friend-group", + GroupType.OIDC, + List.of( + GroupsPermission.Action.READ, + GroupsPermission.Action.ASSIGN_AND_REVOKE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "read_groups", + "groups": { + "group": "friend-group", + "groupType": "oidc" + } + }, + { + "action": "assign_and_revoke_groups", + "groups": { + "group": "friend-group", + "groupType": "oidc" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new NodesPermission( + "Collection", + NodeVerbosity.MINIMAL, + List.of(NodesPermission.Action.READ)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "read_nodes", + "nodes": { + "collection": "Collection", + "verbosity": "minimal" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new ReplicatePermission( + "Collection", + "shard-123", + List.of( + ReplicatePermission.Action.CREATE, + ReplicatePermission.Action.READ, + ReplicatePermission.Action.UPDATE, + ReplicatePermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_replicate", + "replicate": { + "collection": "Collection", + "shard": "shard-123" + } + }, + { + "action": "read_replicate", + "replicate": { + "collection": "Collection", + "shard": "shard-123" + } + }, + { + "action": "update_replicate", + "replicate": { + "collection": "Collection", + "shard": "shard-123" + } + }, + { + "action": "delete_replicate", + "replicate": { + "collection": "Collection", + "shard": "shard-123" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new RolesPermission( + "rock-n-role", + Scope.MATCH, + List.of( + RolesPermission.Action.CREATE, + RolesPermission.Action.READ, + RolesPermission.Action.UPDATE, + RolesPermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_roles", + "roles": { + "role": "rock-n-role", + "scope": "match" + } + }, + { + "action": "read_roles", + "roles": { + "role": "rock-n-role", + "scope": "match" + } + }, + { + "action": "update_roles", + "roles": { + "role": "rock-n-role", + "scope": "match" + } + }, + { + "action": "delete_roles", + "roles": { + "role": "rock-n-role", + "scope": "match" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new TenantsPermission( + "Collection", + "TeenageMutenantNinjaTurtles", + List.of( + TenantsPermission.Action.CREATE, + TenantsPermission.Action.READ, + TenantsPermission.Action.UPDATE, + TenantsPermission.Action.DELETE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_tenants", + "tenants": { + "collection": "Collection", + "tenant": "TeenageMutenantNinjaTurtles" + } + }, + { + "action": "read_tenants", + "tenants": { + "collection": "Collection", + "tenant": "TeenageMutenantNinjaTurtles" + } + }, + { + "action": "update_tenants", + "tenants": { + "collection": "Collection", + "tenant": "TeenageMutenantNinjaTurtles" + } + }, + { + "action": "delete_tenants", + "tenants": { + "collection": "Collection", + "tenant": "TeenageMutenantNinjaTurtles" + } + } + ] + } + """ + }, + { + Role.class, + new Role( + "rock-n-role", + List.of( + new UsersPermission( + "john-doe", + List.of( + UsersPermission.Action.CREATE, + UsersPermission.Action.READ, + UsersPermission.Action.UPDATE, + UsersPermission.Action.DELETE, + UsersPermission.Action.ASSIGN_AND_REVOKE)))), + """ + { + "name": "rock-n-role", + "permissions": [ + { + "action": "create_users", + "users": { + "users": "john-doe" + } + }, + { + "action": "read_users", + "users": { + "users": "john-doe" + } + }, + { + "action": "update_users", + "users": { + "users": "john-doe" + } + }, + { + "action": "delete_users", + "users": { + "users": "john-doe" + } + }, + { + "action": "assign_and_revoke_users", + "users": { + "users": "john-doe" + } + } + ] + } + """ + }, + { + MultiVector.class, + MultiVector.of( + mv -> mv + .aggregation(Aggregation.MAX_SIM) + .encoding(Encoding.muvera( + enc -> enc + .dprojections(1) + .repetitions(2) + .ksim(3)))), + """ + { + "enabled": true, + "aggregation": "MAX_SIM", + "muvera": { + "enabled": true, + "dprojections": 1, + "repetitions": 2, + "ksim": 3 + } + } + """ + }, + + // Generative.CustomTypeAdapterFactory + { + Generative.class, + Generative.anyscale(cfg -> cfg + .baseUrl("https://example.com") + .model("example-model") + .temperature(3f)), + """ + { + "generative-anyscale": { + "baseURL": "https://example.com", + "temperature": 3.0, + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.anthropic(cfg -> cfg + .baseUrl("https://example.com") + .topK(1) + .maxTokens(2) + .temperature(3f) + .model("example-model") + .stopSequences("stop", "halt")), + """ + { + "generative-anthropic": { + "baseURL": "https://example.com", + "topK": 1, + "maxTokens": 2, + "temperature": 3.0, + "model": "example-model", + "stopSequences": ["stop", "halt"] + } + } + """, + }, + { + Generative.class, + Generative.awsBedrock( + "aws-region", + "example-model", + cfg -> cfg + .model("example-model") + .temperature(0.7f) + .maxTokenCount(100) + .topK(50) + .topP(0.9f) + .stopSequences("STOP", "END")), + """ + { + "generative-aws": { + "model": "example-model", + "region": "aws-region", + "service": "bedrock", + "temperature": 0.7, + "maxTokenCount": 100, + "topK": 50, + "topP": 0.9, + "stopSequences": ["STOP", "END"] + } + } + """, + }, + { + Generative.class, + Generative.awsSagemaker( + "aws-region", + "https://example.com", + cfg -> cfg + .endpoint("https://example.com") + .targetModel("custom-model") + .targetVariant("variant-1") + .maxTokensToSample(200) + .stopSequences("STOP")), + """ + { + "generative-aws": { + "endpoint": "https://example.com", + "region": "aws-region", + "service": "sagemaker", + "targetModel": "custom-model", + "targetVariant": "variant-1", + "maxTokensToSample": 200, + "stopSequences": ["STOP"] + } + } + """, + }, + { + Generative.class, + Generative.cohere(cfg -> cfg + .topK(1) + .maxTokens(2) + .temperature(3f) + .model("example-model") + .returnLikelihoodsProperty("likelihood") + .stopSequences("stop", "halt")), + """ + { + "generative-cohere": { + "k": 1, + "maxTokens": 2, + "temperature": 3.0, + "model": "example-model", + "returnLikelihoods": "likelihood", + "stopSequences": ["stop", "halt"] + } + } + """, + }, + { + Generative.class, + Generative.databricks( + "https://example.com", + cfg -> cfg + .topK(1) + .maxTokens(2) + .temperature(3f) + .topP(4f)), + """ + { + "generative-databricks": { + "endpoint": "https://example.com", + "topK": 1, + "maxTokens": 2, + "temperature": 3.0, + "topP": 4.0 + } + } + """, + }, + { + Generative.class, + Generative.friendliai(cfg -> cfg + .baseUrl("https://example.com") + .maxTokens(2) + .temperature(3f) + .model("example-model")), + """ + { + "generative-friendliai": { + "baseURL": "https://example.com", + "maxTokens": 2, + "temperature": 3.0, + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.mistral(cfg -> cfg + .baseUrl("https://example.com") + .maxTokens(2) + .temperature(3f) + .model("example-model")), + """ + { + "generative-mistral": { + "baseURL": "https://example.com", + "maxTokens": 2, + "temperature": 3.0, + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.nvidia(cfg -> cfg + .baseUrl("https://example.com") + .maxTokens(2) + .temperature(3f) + .topP(0.95f) + .model("example-model")), + """ + { + "generative-nvidia": { + "baseURL": "https://example.com", + "maxTokens": 2, + "temperature": 3.0, + "topP": 0.95, + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.googleVertex( + "google-project", + cfg -> cfg + .apiEndpoint("https://example.com") + .maxTokens(2) + .temperature(3f) + .topK(4) + .topP(5f) + .modelId("example-model") + .endpointId("endpoint-123") + .region("us-central1") + .model("gemini-pro")), + """ + { + "generative-google": { + "apiEndpoint": "https://example.com", + "maxOutputTokens": 2, + "temperature": 3.0, + "topK": 4, + "topP": 5, + "projectId": "google-project", + "modelId": "example-model", + "endpointId": "endpoint-123", + "region": "us-central1", + "model": "gemini-pro" + } + } + """, + }, + { + Generative.class, + Generative.ollama(cfg -> cfg + .apiEndpoint("https://example.com") + .model("example-model")), + """ + { + "generative-ollama": { + "apiEndpoint": "https://example.com", + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.xai(cfg -> cfg + .baseUrl("https://example.com") + .maxTokens(2) + .temperature(3f) + .topP(0.9f) + .model("example-model")), + """ + { + "generative-xai": { + "baseURL": "https://example.com", + "maxTokens": 2, + "temperature": 3.0, + "topP": 0.9, + "model": "example-model" + } + } + """, + }, + { + Generative.class, + Generative.openai(cfg -> cfg + .baseUrl("https://example.com") + .frequencyPenalty(1f) + .presencePenalty(2f) + .temperature(3f) + .topP(4f) + .maxTokens(5) + .model("o3-mini")), + """ + { + "generative-openai": { + "baseURL": "https://example.com", + "frequencyPenalty": 1.0, + "presencePenalty": 2.0, + "temperature": 3.0, + "topP": 4.0, + "maxTokens": 5, + "model": "o3-mini" + } + } + """ + }, + { + Generative.class, + Generative.azure( + "azure-resource", + "azure-deployment", + cfg -> cfg + .baseUrl("https://example.com") + .frequencyPenalty(1f) + .presencePenalty(2f) + .temperature(3f) + .topP(4f) + .maxTokens(5)), + """ + { + "generative-openai": { + "baseURL": "https://example.com", + "frequencyPenalty": 1.0, + "presencePenalty": 2.0, + "temperature": 3.0, + "topP": 4.0, + "maxTokens": 5, + "resourceName": "azure-resource", + "deploymentId": "azure-deployment" + } + } + """ + }, + }; + } + + @Test + @DataMethod(source = JSONTest.class, method = "testCases") + public void test_serialize(Object cls, Object in, String want) { + String got; + if (cls instanceof TypeToken typeToken) { + got = JSON.serialize(in, typeToken); + } else { + got = JSON.serialize(in); + } + assertEqualJson(want, got); + + } + + @FunctionalInterface + private interface CustomAssert extends BiConsumer { + } + + @Test + @SuppressWarnings("unchecked") + @DataMethod(source = JSONTest.class, method = "testCases") + public void test_deserialize(Object target, Object want, String in, CustomAssert assertion) { + + Object got; + if (target instanceof Class targetClass) { + got = JSON.deserialize(in, targetClass); + } else if (target instanceof TypeToken targetToken) { + got = JSON.deserialize(in, targetToken); + } else { + throw new IllegalArgumentException("target must be either Class or TypeToken"); + } + + if (assertion != null) { + assertion.accept(got, want); + } else { + Assertions.assertThat(got).isEqualTo(want); + } + } + + private static void assertEqualJson(String want, String got) { + var wantJson = JsonParser.parseString(want); + var gotJson = JsonParser.parseString(got); + Assertions.assertThat(gotJson).isEqualTo(wantJson); + } + + /** + * Custom assert function that uses deep array equality + * to correctly compare float[] and float[][] nested in the object. + */ + private static void compareVectors(Object got, Object want) { + Assertions.assertThat(got) + .usingRecursiveComparison() + .withEqualsForType(Arrays::equals, float[].class) + .withEqualsForType(Arrays::deepEquals, float[][].class) + .isEqualTo(want); + } + + @Test + public void test_ReferenceAddManyResponse_CustomDeserializer() { + var json = """ + [ + { + "result": { "status": "SUCCESS", "errors": {} } + }, + { + "result": { "status": "FAILED", "errors": { + "error": [ "oops" ] + }} + } + ] + """; + + var got = JSON.deserialize(json, ReferenceAddManyResponse.class); + + Assertions.assertThat(got.errors()) + .as("response contains 1 error") + .hasSize(1); + } + + @Test + public void test_CollectionConfig_read_empty() { + var json = """ + { "class": "BarebonesCollection" } + """; + Assertions.assertThatCode(() -> JSON.deserialize(json, CollectionConfig.class)) + .as("deserialize CollectionConfig with no properties") + .doesNotThrowAnyException(); + } +} diff --git a/src/test/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransportTest.java b/src/test/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransportTest.java new file mode 100644 index 000000000..50551c176 --- /dev/null +++ b/src/test/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransportTest.java @@ -0,0 +1,81 @@ +package io.weaviate.client6.v1.internal.rest; + +import java.io.IOException; +import java.util.Collections; +import java.util.concurrent.ExecutionException; + +import javax.net.ssl.TrustManagerFactory; + +import org.assertj.core.api.Assertions; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockserver.integration.ClientAndServer; +import org.mockserver.model.HttpRequest; + +import io.weaviate.client6.v1.internal.Timeout; +import io.weaviate.testutil.truststore.SingleTrustManagerFactory; +import io.weaviate.testutil.truststore.SpyTrustManager; + +public class DefaultRestTransportTest { + private ClientAndServer mockServer; + private DefaultRestTransport transport; + private TrustManagerFactory tmf; + + @Before + public void setUp() throws IOException { + // MockServer does not verify exclusive ownership of the port + // and using any well-known port like 8080 will produce flaky + // test results with fairly confusing errors, like: + // + // path /mockserver/verifySequence was not found + // + // if another webserver is listening to that port. + // We use 0 to let the underlying system find an available port. + mockServer = ClientAndServer.startClientAndServer(0); + mockServer.withSecure(true); + + tmf = SingleTrustManagerFactory.create(new SpyTrustManager()); + transport = new DefaultRestTransport(new RestTransportOptions( + "https", "localhost", mockServer.getLocalPort(), + Collections.emptyMap(), null, tmf, new Timeout())); + } + + @Test + public void testCustomTrustStore_sync() throws IOException { + transport.performRequest(null, OptionalEndpoint.noBodyOptional( + request -> "GET", request -> "/", request -> null, (code, response) -> null)); + + mockServer.verify( + HttpRequest.request() + .withMethod("GET") + .withPath("/v1/")); + + var spy = SpyTrustManager.getSpy(tmf); + Assertions.assertThat(spy).get() + .as("HttpClient uses custom TrustManager") + .returns(true, SpyTrustManager::wasUsed); + } + + @Test + public void testCustomTrustStore_async() throws IOException, ExecutionException, InterruptedException { + transport.performRequestAsync(null, OptionalEndpoint.noBodyOptional( + request -> "GET", request -> "/", request -> null, (code, response) -> null)).get(); + + mockServer.verify( + HttpRequest.request() + .withMethod("GET") + .withPath("/v1/")); + + var spy = SpyTrustManager.getSpy(tmf); + Assertions.assertThat(spy).get() + .as("HttpClient uses custom TrustManager") + .returns(true, SpyTrustManager::wasUsed); + } + + @After + public void tearDown() throws Exception { + mockServer.stop(); + transport.close(); + } +} diff --git a/src/test/java/io/weaviate/integration/client/AssertMultiTenancy.java b/src/test/java/io/weaviate/integration/client/AssertMultiTenancy.java deleted file mode 100644 index 3b227226f..000000000 --- a/src/test/java/io/weaviate/integration/client/AssertMultiTenancy.java +++ /dev/null @@ -1,124 +0,0 @@ -package io.weaviate.integration.client; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.ActivityStatus; -import io.weaviate.client.v1.schema.model.Tenant; - -import java.util.List; -import java.util.Objects; -import java.util.Optional; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.STRING; - -public class AssertMultiTenancy { - - private WeaviateClient client; - - public AssertMultiTenancy(WeaviateClient client) { - this.client = client; - } - - public void objectExists(String className, String id, String tenant) { - Result checkResult = client.data().checker() - .withClassName(className) - .withID(id) - .withTenant(tenant) - .run(); - - assertThat(checkResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - public void objectDoesNotExist(String className, String id, String tenant) { - Result checkResult = client.data().checker() - .withClassName(className) - .withID(id) - .withTenant(tenant) - .run(); - - assertThat(checkResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(false, Result::getResult); - } - - public void countObjects(String tenant, int expectedCount) { - countObjects(null, tenant, expectedCount); - } - - public void countObjects(String className, String tenant, int expectedCount) { - Result> getResultByClass = client.data().objectsGetter() - .withTenant(tenant) - .withClassName(className) - .run(); - - assertThat(getResultByClass).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(expectedCount); - } - - public void error(Result result, T expectedValue, int expectedStatusCode, String... expectedContains) { - assertThat(result).isNotNull() - .returns(expectedValue, Result::getResult) - .returns(true, Result::hasErrors) - .extracting(Result::getError) - .returns(expectedStatusCode, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .first() - .extracting(m -> ((WeaviateErrorMessage) m).getMessage()).asInstanceOf(STRING) - .contains(expectedContains); - } - - public void tenantActive(String className, String tenantName) { - tenantStatus(className, tenantName, ActivityStatus.HOT); - } - - public void tenantInactive(String className, String tenantName) { - tenantStatus(className, tenantName, ActivityStatus.COLD); - } - - private void tenantStatus(String className, String tenantName, String activityStatus) { - Result> result = client.schema().tenantsGetter() - .withClassName(className) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - Optional maybeTenant = result.getResult().stream() - .filter(Objects::nonNull) - .filter(tenant -> tenantName.equals(tenant.getName())) - .filter(tenant -> activityStatus.equals(tenant.getActivityStatus())) - .findFirst(); - - assertThat(maybeTenant).isNotEmpty(); - } - - public void tenantActiveGetsObjects(String className, String tenantName, int objectsCount) { - Result> result = client.data().objectsGetter() - .withClassName(className) - .withTenant(tenantName) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(objectsCount); - } - - public void tenantInactiveGetsNoObjects(String className, String tenantName) { - Result> result = client.data().objectsGetter() - .withClassName(className) - .withTenant(tenantName) - .run(); - - error(result, null, 422, "tenant not active"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateDockerCompose.java b/src/test/java/io/weaviate/integration/client/WeaviateDockerCompose.java deleted file mode 100644 index 5a2d1a165..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateDockerCompose.java +++ /dev/null @@ -1,138 +0,0 @@ -package io.weaviate.integration.client; - -import java.util.ArrayList; -import java.util.List; - -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; -import org.testcontainers.containers.GenericContainer; -import org.testcontainers.containers.MinIOContainer; -import org.testcontainers.containers.Network; -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateDockerCompose implements TestRule { - - /** Weaviate Docker image to create a container from. */ - private final String weaviateVersion; - private final boolean withOffloadS3; - - public WeaviateDockerCompose() { - this.weaviateVersion = WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE; - this.withOffloadS3 = false; - } - - public WeaviateDockerCompose(String version) { - this.weaviateVersion = String.format("semitechnologies/weaviate:%s", version); - this.withOffloadS3 = false; - } - - public WeaviateDockerCompose(String version, boolean withOffloadS3) { - this.weaviateVersion = String.format("semitechnologies/weaviate:%s", version); - this.withOffloadS3 = withOffloadS3; - } - - public static class Weaviate extends WeaviateContainer { - public Weaviate(String dockerImageName, boolean withOffloadS3) { - super(dockerImageName); - waitingFor(Wait.forHttp("/v1/.well-known/ready").forPort(8080).forStatusCode(200)); - withNetwork(Network.SHARED); - List enableModules = new ArrayList<>(); - enableModules.add("text2vec-contextionary"); - enableModules.add("backup-filesystem"); - enableModules.add("generative-openai"); - if (withOffloadS3) { - enableModules.add("offload-s3"); - withEnv("OFFLOAD_S3_ENDPOINT", "http://minio:9000"); - withEnv("OFFLOAD_S3_BUCKET_AUTO_CREATE", "true"); - withEnv("AWS_ACCESS_KEY_ID", MinIO.USER); - withEnv("AWS_SECRET_KEY", MinIO.PASSWORD); - } - withEnv("LOG_LEVEL", "debug"); - withEnv("CONTEXTIONARY_URL", "contextionary:9999"); - withEnv("QUERY_DEFAULTS_LIMIT", "25"); - withEnv("DEFAULT_VECTORIZER_MODULE", "text2vec-contextionary"); - withEnv("BACKUP_FILESYSTEM_PATH", "/tmp/backups"); - withEnv("DISABLE_TELEMETRY", "true"); - withEnv("PERSISTENCE_FLUSH_IDLE_MEMTABLES_AFTER", "1"); - withEnv("ENABLE_MODULES", String.join(",", enableModules)); - withEnv("AUTHENTICATION_DB_USERS_ENABLED", "true"); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("weaviate")); - } - } - - public static class Contextionary extends GenericContainer { - public Contextionary() { - super("semitechnologies/contextionary:en0.16.0-v1.2.1"); - withNetwork(Network.SHARED); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "true"); - withEnv("PERSISTENCE_DATA_PATH", "/var/lib/weaviate"); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "0.75"); - withEnv("EXTENSIONS_STORAGE_MODE", "weaviate"); - withEnv("EXTENSIONS_STORAGE_ORIGIN", "http://weaviate:8080"); - withEnv("NEIGHBOR_OCCURRENCE_IGNORE_PERCENTILE", "5"); - withEnv("ENABLE_COMPOUND_SPLITTING", "'false'"); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("contextionary")); - } - } - - public static class MinIO extends MinIOContainer { - private static final String USER = "minioadmin"; - private static final String PASSWORD = "minioadmin"; - - public MinIO() { - super("minio/minio"); - withNetwork(Network.SHARED); - withUserName(USER); - withPassword(PASSWORD); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("minio")); - } - } - - private static Contextionary contextionary; - private static Weaviate weaviate; - private static MinIO minio; - - public void start() { - if (withOffloadS3) { - minio = new MinIO(); - minio.start(); - } - contextionary = new Contextionary(); - contextionary.start(); - weaviate = new Weaviate(this.weaviateVersion, this.withOffloadS3); - weaviate.start(); - } - - public String getHttpHostAddress() { - return weaviate.getHttpHostAddress(); - } - - public String getGrpcHostAddress() { - return weaviate.getGrpcHostAddress(); - } - - public void stop() { - weaviate.stop(); - contextionary.stop(); - if (withOffloadS3) { - minio.stop(); - } - } - - @Override - public Statement apply(Statement base, Description description) { - return new Statement() { - @Override - public void evaluate() throws Throwable { - try { - start(); - base.evaluate(); - } finally { - stop(); - } - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeBackup.java b/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeBackup.java deleted file mode 100644 index 35f20c089..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeBackup.java +++ /dev/null @@ -1,157 +0,0 @@ -package io.weaviate.integration.client; - -import java.util.ArrayList; -import java.util.List; - -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; -import org.testcontainers.containers.GenericContainer; -import org.testcontainers.containers.MinIOContainer; -import org.testcontainers.containers.Network; -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateDockerComposeBackup implements TestRule { - - public static final String ADMIN_KEY = "admin-key"; - - /** Weaviate Docker image to create a container from. */ - private final String weaviateVersion; - private final boolean withOffloadS3; - - public WeaviateDockerComposeBackup() { - this.weaviateVersion = WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE; - this.withOffloadS3 = false; - } - - public WeaviateDockerComposeBackup(String version) { - this.weaviateVersion = String.format("semitechnologies/weaviate:%s", version); - this.withOffloadS3 = false; - } - - public WeaviateDockerComposeBackup(String version, boolean withOffloadS3) { - this.weaviateVersion = String.format("semitechnologies/weaviate:%s", version); - this.withOffloadS3 = withOffloadS3; - } - - public static class Weaviate extends WeaviateContainer { - public Weaviate(String dockerImageName, boolean withOffloadS3) { - super(dockerImageName); - waitingFor(Wait.forHttp("/v1/.well-known/ready").forPort(8080).forStatusCode(200)); - withNetwork(Network.SHARED); - List enableModules = new ArrayList<>(); - enableModules.add("text2vec-contextionary"); - enableModules.add("backup-filesystem"); - enableModules.add("generative-openai"); - if (withOffloadS3) { - enableModules.add("offload-s3"); - withEnv("OFFLOAD_S3_ENDPOINT", "http://minio:9000"); - withEnv("OFFLOAD_S3_BUCKET_AUTO_CREATE", "true"); - withEnv("AWS_ACCESS_KEY_ID", MinIO.USER); - withEnv("AWS_SECRET_KEY", MinIO.PASSWORD); - } - withEnv("LOG_LEVEL", "debug"); - withEnv("CONTEXTIONARY_URL", "contextionary:9999"); - withEnv("QUERY_DEFAULTS_LIMIT", "25"); - withEnv("DEFAULT_VECTORIZER_MODULE", "text2vec-contextionary"); - withEnv("BACKUP_FILESYSTEM_PATH", "/tmp/backups"); - withEnv("DISABLE_TELEMETRY", "true"); - withEnv("PERSISTENCE_FLUSH_IDLE_MEMTABLES_AFTER", "1"); - withEnv("ENABLE_MODULES", String.join(",", enableModules)); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("weaviate")); - - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_APIKEY_ENABLED", "true"); - withEnv("AUTHENTICATION_APIKEY_ALLOWED_KEYS", ADMIN_KEY + ",custom-key"); - withEnv("AUTHENTICATION_APIKEY_USERS", "admin-user,custom-user"); - withEnv("AUTHORIZATION_ADMIN_USERS", "admin-user"); - withEnv("PERSISTENCE_DATA_PATH", "./data-weaviate-0"); - withEnv("CLUSTER_IN_LOCALHOST", "true"); - withEnv("CLUSTER_GOSSIP_BIND_PORT", "7100"); - withEnv("CLUSTER_DATA_BIND_PORT", "7101"); - withEnv("RAFT_BOOTSTRAP_EXPECT", "1"); - withEnv("AUTHORIZATION_ENABLE_RBAC", "true"); - withEnv("AUTHENTICATION_DB_USERS_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "wcs"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://auth.wcs.api.weaviate.io/auth/realms/SeMI"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "email"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - } - } - - public static class Contextionary extends GenericContainer { - public Contextionary() { - super("semitechnologies/contextionary:en0.16.0-v1.2.1"); - withNetwork(Network.SHARED); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "true"); - withEnv("PERSISTENCE_DATA_PATH", "/var/lib/weaviate"); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "0.75"); - withEnv("EXTENSIONS_STORAGE_MODE", "weaviate"); - withEnv("EXTENSIONS_STORAGE_ORIGIN", "http://weaviate:8080"); - withEnv("NEIGHBOR_OCCURRENCE_IGNORE_PERCENTILE", "5"); - withEnv("ENABLE_COMPOUND_SPLITTING", "'false'"); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("contextionary")); - } - } - - public static class MinIO extends MinIOContainer { - private static final String USER = "minioadmin"; - private static final String PASSWORD = "minioadmin"; - - public MinIO() { - super("minio/minio"); - withNetwork(Network.SHARED); - withUserName(USER); - withPassword(PASSWORD); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("minio")); - } - } - - private static Contextionary contextionary; - private static Weaviate weaviate; - private static MinIO minio; - - public void start() { - if (withOffloadS3) { - minio = new MinIO(); - minio.start(); - } - contextionary = new Contextionary(); - contextionary.start(); - weaviate = new Weaviate(this.weaviateVersion, this.withOffloadS3); - weaviate.start(); - } - - public String getHttpHostAddress() { - return weaviate.getHttpHostAddress(); - } - - public String getGrpcHostAddress() { - return weaviate.getGrpcHostAddress(); - } - - public void stop() { - weaviate.stop(); - contextionary.stop(); - if (withOffloadS3) { - minio.stop(); - } - } - - @Override - public Statement apply(Statement base, Description description) { - return new Statement() { - @Override - public void evaluate() throws Throwable { - try { - start(); - base.evaluate(); - } finally { - stop(); - } - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeCluster.java b/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeCluster.java deleted file mode 100644 index 4da5cc665..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateDockerComposeCluster.java +++ /dev/null @@ -1,111 +0,0 @@ -package io.weaviate.integration.client; - -import java.time.Duration; - -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.model.Statement; -import org.testcontainers.containers.GenericContainer; -import org.testcontainers.containers.Network; -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateDockerComposeCluster implements TestRule { - - public static class Weaviate extends WeaviateContainer { - public Weaviate(String dockerImageName, String hostname, Boolean isJoining) { - super(dockerImageName); - withNetwork(Network.SHARED); - withCreateContainerCmdModifier(cmd -> { - cmd.withHostName(hostname); - }); - withEnv("LOG_LEVEL", "debug"); - withEnv("CONTEXTIONARY_URL", "contextionary:9999"); - withEnv("QUERY_DEFAULTS_LIMIT", "25"); - withEnv("DEFAULT_VECTORIZER_MODULE", "text2vec-contextionary"); - withEnv("ENABLE_MODULES", "text2vec-contextionary,backup-filesystem,generative-openai"); - withEnv("BACKUP_FILESYSTEM_PATH", "/tmp/backups"); - withEnv("DISABLE_TELEMETRY", "true"); - withEnv("PERSISTENCE_FLUSH_IDLE_MEMTABLES_AFTER", "1"); - - withEnv("CLUSTER_GOSSIP_BIND_PORT", "7110"); - withEnv("CLUSTER_DATA_BIND_PORT", "7111"); - withEnv("RAFT_PORT", "8300"); - - withEnv("RAFT_BOOTSTRAP_EXPECT", "1"); - withEnv("RAFT_JOIN", "weaviate-0"); - if (isJoining) { - withEnv("CLUSTER_JOIN", "weaviate-0:7110"); - waitingFor(Wait.forHttp("/v1/.well-known/ready").forPort(8080).forStatusCode(200) - .withStartupTimeout(Duration.ofSeconds(10))); - } - - withEnv("REPLICA_MOVEMENT_ENABLED", "true"); - } - } - - public static class Contextionary extends GenericContainer { - public Contextionary() { - super("semitechnologies/contextionary:en0.16.0-v1.2.1"); - withNetwork(Network.SHARED); - withCreateContainerCmdModifier(cmd -> cmd.withHostName("contextionary")); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "true"); - withEnv("PERSISTENCE_DATA_PATH", "/var/lib/weaviate"); - withEnv("OCCURRENCE_WEIGHT_LINEAR_FACTOR", "0.75"); - withEnv("EXTENSIONS_STORAGE_MODE", "weaviate"); - withEnv("EXTENSIONS_STORAGE_ORIGIN", "http://weaviate-0:8080"); - withEnv("NEIGHBOR_OCCURRENCE_IGNORE_PERCENTILE", "5"); - withEnv("ENABLE_COMPOUND_SPLITTING", "'false'"); - } - } - - private static Contextionary contextionary; - private static Weaviate weaviate0; - private static Weaviate weaviate1; - - public void start() { - contextionary = new Contextionary(); - contextionary.start(); - weaviate0 = new Weaviate(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE, "weaviate-0", false); - weaviate1 = new Weaviate(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE, "weaviate-1", true); - weaviate0.start(); - weaviate1.start(); - } - - public String getHttpHost0Address() { - return weaviate0.getHttpHostAddress(); - } - - public String getGrpcHost0Address() { - return weaviate0.getGrpcHostAddress(); - } - - public String getHttpHost1Address() { - return weaviate1.getHttpHostAddress(); - } - - public String getGrpcHost1Address() { - return weaviate1.getGrpcHostAddress(); - } - - public void stop() { - weaviate0.stop(); - weaviate1.stop(); - contextionary.stop(); - } - - @Override - public Statement apply(Statement base, Description description) { - return new Statement() { - @Override - public void evaluate() throws Throwable { - try { - start(); - base.evaluate(); - } finally { - stop(); - } - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateDockerImage.java b/src/test/java/io/weaviate/integration/client/WeaviateDockerImage.java deleted file mode 100644 index f7b65399d..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateDockerImage.java +++ /dev/null @@ -1,7 +0,0 @@ -package io.weaviate.integration.client; - -public class WeaviateDockerImage { - - public static final String WEAVIATE_DOCKER_IMAGE = String.format("semitechnologies/weaviate:%s", WeaviateVersion.WEAVIATE_IMAGE); - -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateTestGenerics.java b/src/test/java/io/weaviate/integration/client/WeaviateTestGenerics.java deleted file mode 100644 index 687823b08..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateTestGenerics.java +++ /dev/null @@ -1,1286 +0,0 @@ -package io.weaviate.integration.client; - -import com.google.gson.Gson; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.InvertedIndexConfig; -import io.weaviate.client.v1.misc.model.MultiTenancyConfig; -import io.weaviate.client.v1.misc.model.ReplicationConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.client.v1.schema.model.Tokenization; -import io.weaviate.client.v1.schema.model.WeaviateClass; - -import java.io.File; -import java.io.IOException; -import java.io.InputStreamReader; -import java.nio.file.Files; -import java.time.ZoneOffset; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Collections; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.TimeZone; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; -import java.util.function.Supplier; - -import java.util.stream.IntStream; -import java.util.stream.Stream; -import org.apache.commons.lang3.time.DateFormatUtils; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -public class WeaviateTestGenerics { - - public static final String PIZZA_QUATTRO_FORMAGGI_ID = "10523cdd-15a2-42f4-81fa-267fe92f7cd6"; - public static final String PIZZA_FRUTTI_DI_MARE_ID = "927dd3ac-e012-4093-8007-7799cc7e81e4"; - public static final String PIZZA_HAWAII_ID = "00000000-0000-0000-0000-000000000000"; - public static final String PIZZA_DOENER_ID = "d2b393ff-4b26-48c7-b554-218d970a9e17"; - public static final String SOUP_CHICKENSOUP_ID = "8c156d37-81aa-4ce9-a811-621e2702b825"; - public static final String SOUP_BEAUTIFUL_ID = "27351361-2898-4d1a-aad7-1ca48253eb0b"; - - public static final Map> IDS_BY_CLASS = new HashMap<>(); - public static final List IDS_ALL = Arrays.asList( - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - WeaviateTestGenerics.PIZZA_HAWAII_ID, - WeaviateTestGenerics.PIZZA_DOENER_ID, - WeaviateTestGenerics.SOUP_CHICKENSOUP_ID, - WeaviateTestGenerics.SOUP_BEAUTIFUL_ID - ); - - static { - IDS_BY_CLASS.put("Pizza", Arrays.asList( - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - WeaviateTestGenerics.PIZZA_HAWAII_ID, - WeaviateTestGenerics.PIZZA_DOENER_ID - )); - IDS_BY_CLASS.put("Soup", Arrays.asList( - WeaviateTestGenerics.SOUP_CHICKENSOUP_ID, - WeaviateTestGenerics.SOUP_BEAUTIFUL_ID - )); - } - - public static final Tenant TENANT_1 = Tenant.builder() - .name("TenantNo1") - .build(); - public static final Tenant TENANT_2 = Tenant.builder() - .name("TenantNo2") - .build(); - - - public void createWeaviateTestSchemaFood(WeaviateClient client) { - createWeaviateTestSchemaFood(client, false); - } - - public void createWeaviateTestSchemaFoodAsync(WeaviateAsyncClient client) throws ExecutionException, InterruptedException { - createWeaviateTestSchemaFoodAsync(client, false); - } - - public void createWeaviateTestSchemaFood(WeaviateClient client, boolean deprecatedMode) { - try { - createWeaviateTestSchemaFoodWithClients(client, null, deprecatedMode); - } catch (ExecutionException | InterruptedException e) { - // ignoring bc there are no exceptions from sync client - } - } - - public void createWeaviateTestSchemaFoodAsync(WeaviateAsyncClient client, boolean deprecatedMode) throws ExecutionException, InterruptedException { - createWeaviateTestSchemaFoodWithClients(null, client, deprecatedMode); - } - - private void createWeaviateTestSchemaFoodWithClients(WeaviateClient client, WeaviateAsyncClient asyncClient, boolean deprecatedMode) throws ExecutionException, InterruptedException { - // classes - WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .invertedIndexConfig(InvertedIndexConfig.builder().indexTimestamps(true).build()) - .build(); - WeaviateClass soup = WeaviateClass.builder() - .className("Soup") - .description("Mostly water based brew of sustenance for humans.") - .build(); - // create Pizza class - Result pizzaCreateStatus; - if (asyncClient != null) { - pizzaCreateStatus = asyncClient.schema().classCreator().withClass(pizza).run().get(); - } else { - pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - } - assertNotNull(pizzaCreateStatus); - assertTrue(pizzaCreateStatus.getResult()); - // create Soup class - Result soupCreateStatus; - if (asyncClient != null) { - soupCreateStatus = asyncClient.schema().classCreator().withClass(soup).run().get(); - } else { - soupCreateStatus = client.schema().classCreator().withClass(soup).run(); - } - assertNotNull(soupCreateStatus); - assertTrue(soupCreateStatus.getResult()); - - // properties - Property nameProperty = deprecatedMode - ? Property.builder() - .dataType(Arrays.asList(DataType.STRING)) - .description("name") - .name("name") - .tokenization(Tokenization.FIELD) - .build() - : Property.builder() - .dataType(Arrays.asList(DataType.TEXT)) - .description("name") - .name("name") - .tokenization(Tokenization.FIELD) - .build(); - Property descriptionProperty = Property.builder() - .dataType(Arrays.asList(DataType.TEXT)) - .description("description") - .name("description") - .tokenization(Tokenization.WORD) - .build(); - Property bestBeforeProperty = Property.builder() - .dataType(Arrays.asList(DataType.DATE)) - .description("best before") - .name("bestBefore") - .build(); - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("skip", true); - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - Property priceProperty = Property.builder() - .dataType(Arrays.asList(DataType.NUMBER)) - .description("price") - .name("price") - .moduleConfig(moduleConfig) - .build(); - // Add name and description properties to Pizza - Result pizzaPropertyNameStatus; - if (asyncClient != null) { - pizzaPropertyNameStatus = asyncClient.schema().propertyCreator() - .withProperty(nameProperty).withClassName(pizza.getClassName()).run().get(); - } else { - pizzaPropertyNameStatus = client.schema().propertyCreator() - .withProperty(nameProperty).withClassName(pizza.getClassName()).run(); - } - assertNotNull(pizzaPropertyNameStatus); - assertTrue(pizzaPropertyNameStatus.getResult()); - Result pizzaPropertyDescriptionStatus; - if (asyncClient != null) { - pizzaPropertyDescriptionStatus = asyncClient.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(pizza.getClassName()).run().get(); - } else { - pizzaPropertyDescriptionStatus = client.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(pizza.getClassName()).run(); - } - assertNotNull(pizzaPropertyDescriptionStatus); - assertTrue(pizzaPropertyDescriptionStatus.getResult()); - Result pizzaPropertyBestBeforeStatus; - if (asyncClient != null) { - pizzaPropertyBestBeforeStatus = asyncClient.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(pizza.getClassName()).run().get(); - } else { - pizzaPropertyBestBeforeStatus = client.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(pizza.getClassName()).run(); - } - assertNotNull(pizzaPropertyBestBeforeStatus); - assertTrue(pizzaPropertyBestBeforeStatus.getResult()); - Result pizzaPropertyPriceStatus; - if (asyncClient != null) { - pizzaPropertyPriceStatus = asyncClient.schema().propertyCreator() - .withProperty(priceProperty).withClassName(pizza.getClassName()).run().get(); - } else { - pizzaPropertyPriceStatus = client.schema().propertyCreator() - .withProperty(priceProperty).withClassName(pizza.getClassName()).run(); - } - assertNotNull(pizzaPropertyPriceStatus); - assertTrue(pizzaPropertyPriceStatus.getResult()); - // Add name and description properties to Soup - Result soupPropertyNameStatus; - if (asyncClient != null) { - soupPropertyNameStatus = asyncClient.schema().propertyCreator() - .withProperty(nameProperty).withClassName(soup.getClassName()).run().get(); - } else { - soupPropertyNameStatus = client.schema().propertyCreator() - .withProperty(nameProperty).withClassName(soup.getClassName()).run(); - } - assertNotNull(soupPropertyNameStatus); - assertTrue(soupPropertyNameStatus.getResult()); - Result soupPropertyDescriptionStatus; - if (asyncClient != null) { - soupPropertyDescriptionStatus = asyncClient.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(soup.getClassName()).run().get(); - } else { - soupPropertyDescriptionStatus = client.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(soup.getClassName()).run(); - } - assertNotNull(soupPropertyDescriptionStatus); - assertTrue(soupPropertyDescriptionStatus.getResult()); - Result soupPropertyBestBeforeStatus; - if (asyncClient != null) { - soupPropertyBestBeforeStatus = asyncClient.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(soup.getClassName()).run().get(); - } else { - soupPropertyBestBeforeStatus = client.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(soup.getClassName()).run(); - } - assertNotNull(soupPropertyBestBeforeStatus); - assertTrue(soupPropertyBestBeforeStatus.getResult()); - Result soupPropertyPriceStatus; - if (asyncClient != null) { - soupPropertyPriceStatus = asyncClient.schema().propertyCreator() - .withProperty(priceProperty).withClassName(soup.getClassName()).run().get(); - } else { - soupPropertyPriceStatus = client.schema().propertyCreator() - .withProperty(priceProperty).withClassName(soup.getClassName()).run(); - } - assertNotNull(soupPropertyPriceStatus); - assertTrue(soupPropertyPriceStatus.getResult()); - } - - public void createWeaviateTestSchemaFoodWithReferenceProperty(WeaviateClient client) { - createWeaviateTestSchemaFoodWithReferenceProperty(client, false); - } - - public void createWeaviateTestSchemaFoodWithReferenceProperty(WeaviateClient client, boolean deprecatedMode) { - createWeaviateTestSchemaFood(client, deprecatedMode); - - // reference property - Property referenceProperty = Property.builder() - .dataType(Arrays.asList("Pizza", "Soup")) - .description("reference to other foods") - .name("otherFoods") - .build(); - Result pizzaRefAdd = client.schema().propertyCreator().withClassName("Pizza").withProperty(referenceProperty).run(); - assertNotNull(pizzaRefAdd); - assertTrue(pizzaRefAdd.getResult()); - Result soupRefAdd = client.schema().propertyCreator().withClassName("Soup").withProperty(referenceProperty).run(); - assertNotNull(soupRefAdd); - assertTrue(soupRefAdd.getResult()); - } - - public void createTestSchemaAndData(WeaviateClient client) { - createTestSchemaAndData(client, false); - } - - public void createTestSchemaAndData(WeaviateClient client, boolean deprecatedMode) { - createWeaviateTestSchemaFood(client, deprecatedMode); - - // Create pizzas - WeaviateObject[] menuPizza = new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener() - }; - // Create soups - WeaviateObject[] menuSoup = new WeaviateObject[]{ - objectSoupChicken(), - objectSoupBeautiful() - }; - Result insertStatus = client.batch().objectsBatcher() - .withObjects(menuPizza) - .withObjects(menuSoup) - .run(); - assertNotNull(insertStatus); - assertNotNull(insertStatus.getResult()); - assertEquals(6, insertStatus.getResult().length); - } - - public void createReplicatedTestSchemaAndData(WeaviateClient client) { - createWeaviateReplicatedTestSchemaFood(client); - - // Create pizzas - WeaviateObject[] menuPizza = new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener() - }; - // Create soups - WeaviateObject[] menuSoup = new WeaviateObject[]{ - objectSoupChicken(), - objectSoupBeautiful() - }; - Result insertStatus = client.batch().objectsBatcher() - .withObjects(menuPizza) - .withObjects(menuSoup) - .run(); - assertNotNull(insertStatus); - assertNotNull(insertStatus.getResult()); - assertEquals(6, insertStatus.getResult().length); - } - - public void createWeaviateReplicatedTestSchemaFood(WeaviateClient client) { - // classes - WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .invertedIndexConfig(InvertedIndexConfig.builder().indexTimestamps(true).build()) - .replicationConfig(ReplicationConfig.builder().factor(2).build()) - .build(); - WeaviateClass soup = WeaviateClass.builder() - .className("Soup") - .description("Mostly water based brew of sustenance for humans.") - .replicationConfig(ReplicationConfig.builder().factor(2).build()) - .build(); - // create Pizza class - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - assertNotNull(pizzaCreateStatus); - assertTrue(pizzaCreateStatus.getResult()); - // create Soup class - Result soupCreateStatus = client.schema().classCreator().withClass(soup).run(); - assertNotNull(soupCreateStatus); - assertTrue(soupCreateStatus.getResult()); - // properties - Property nameProperty = Property.builder() - .dataType(Arrays.asList(DataType.STRING)) - .description("name") - .name("name") - .tokenization(Tokenization.FIELD) - .build(); - Property descriptionProperty = Property.builder() - .dataType(Arrays.asList(DataType.TEXT)) - .description("description") - .name("description") - .tokenization(Tokenization.WORD) - .build(); - Property bestBeforeProperty = Property.builder() - .dataType(Arrays.asList(DataType.DATE)) - .description("best before") - .name("bestBefore") - .build(); - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("skip", true); - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - Property priceProperty = Property.builder() - .dataType(Arrays.asList(DataType.NUMBER)) - .description("price") - .name("price") - .moduleConfig(moduleConfig) - .build(); - // Add name and description properties to Pizza - Result pizzaPropertyNameStatus = client.schema().propertyCreator() - .withProperty(nameProperty).withClassName(pizza.getClassName()).run(); - assertNotNull(pizzaPropertyNameStatus); - assertTrue(pizzaPropertyNameStatus.getResult()); - Result pizzaPropertyDescriptionStatus = client.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(pizza.getClassName()).run(); - assertNotNull(pizzaPropertyDescriptionStatus); - assertTrue(pizzaPropertyDescriptionStatus.getResult()); - Result pizzaPropertyBestBeforeStatus = client.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(pizza.getClassName()).run(); - assertNotNull(pizzaPropertyBestBeforeStatus); - assertTrue(pizzaPropertyBestBeforeStatus.getResult()); - Result pizzaPropertyPriceStatus = client.schema().propertyCreator() - .withProperty(priceProperty).withClassName(pizza.getClassName()).run(); - assertNotNull(pizzaPropertyPriceStatus); - assertTrue(pizzaPropertyPriceStatus.getResult()); - // Add name and description properties to Soup - Result soupPropertyNameStatus = client.schema().propertyCreator() - .withProperty(nameProperty).withClassName(soup.getClassName()).run(); - assertNotNull(soupPropertyNameStatus); - assertTrue(soupPropertyNameStatus.getResult()); - Result soupPropertyDescriptionStatus = client.schema().propertyCreator() - .withProperty(descriptionProperty).withClassName(soup.getClassName()).run(); - assertNotNull(soupPropertyDescriptionStatus); - assertTrue(soupPropertyDescriptionStatus.getResult()); - Result soupPropertyBestBeforeStatus = client.schema().propertyCreator() - .withProperty(bestBeforeProperty).withClassName(soup.getClassName()).run(); - assertNotNull(soupPropertyBestBeforeStatus); - assertTrue(soupPropertyBestBeforeStatus.getResult()); - Result soupPropertyPriceStatus = client.schema().propertyCreator() - .withProperty(priceProperty).withClassName(soup.getClassName()).run(); - assertNotNull(soupPropertyPriceStatus); - assertTrue(soupPropertyPriceStatus.getResult()); - } - - private WeaviateObject createObject(String id, String className, String name, String description, Float price, String bestBeforeRfc3339) { - return WeaviateObject.builder() - .id(id) - .className(className) - .properties(new HashMap() {{ - put("name", name); - put("description", description); - put("price", price); - put("bestBefore", bestBeforeRfc3339); - }}).build(); - } - - public void cleanupWeaviate(WeaviateClient client) { - Result deleteAllStatus = client.schema().allDeleter().run(); - assertNotNull(deleteAllStatus); - assertTrue(deleteAllStatus.getResult()); - } - - public void cleanupWeaviateAsync(WeaviateAsyncClient client) throws ExecutionException, InterruptedException { - Result deleteAllStatus = client.schema().allDeleter().run().get(); - assertNotNull(deleteAllStatus); - assertTrue(deleteAllStatus.getResult()); - } - - public void createSchemaPizza(WeaviateClient client) { - createSchema(client, classPizza()); - } - - public void createSchemaSoup(WeaviateClient client) { - createSchema(client, classSoup()); - } - - public void createSchemaFood(WeaviateClient client) { - createSchemaPizza(client); - createSchemaSoup(client); - } - - public void createSchemaPizzaForTenants(WeaviateClient client) { - createSchema(client, classPizzaForTenants()); - } - - public void createSchemaSoupForTenants(WeaviateClient client) { - createSchema(client, classSoupForTenants()); - } - - public void createSchemaFoodForTenants(WeaviateClient client) { - createSchemaPizzaForTenants(client); - createSchemaSoupForTenants(client); - } - - private void createSchema(WeaviateClient client, WeaviateClass cl) { - Result createStatus = client.schema().classCreator().withClass(cl).run(); - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - - public void createTenantsPizza(WeaviateClient client, Tenant... tenants) { - createTenants(client, "Pizza", tenants); - } - - public void createTenantsSoup(WeaviateClient client, Tenant... tenants) { - createTenants(client, "Soup", tenants); - } - - public void createTenantsFood(WeaviateClient client, Tenant... tenants) { - createTenantsPizza(client, tenants); - createTenantsSoup(client, tenants); - } - - private void createTenants(WeaviateClient client, String className, Tenant[] tenants) { - Result createStatus = client.schema().tenantsCreator() - .withClassName(className) - .withTenants(tenants) - .run(); - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - - public void createDataPizza(WeaviateClient client) { - createData(client, new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener(), - }); - } - - public void createDataSoup(WeaviateClient client) { - createData(client, new WeaviateObject[]{ - objectSoupChicken(), - objectSoupBeautiful(), - }); - } - - public void createDataFood(WeaviateClient client) { - createData(client, new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener(), - objectSoupChicken(), - objectSoupBeautiful(), - }); - } - - private void createData(WeaviateClient client, WeaviateObject[] objects) { - Result insertStatus = client.batch().objectsBatcher() - .withObjects(objects) - .run(); - - assertThat(insertStatus).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(objects.length); - } - - public void createDataPizzaQuattroFormaggiForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - }); - } - - public void createDataPizzaFruttiDiMareForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaFruttiDiMare(), - }); - } - - public void createDataPizzaHawaiiForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaHawaii(), - }); - } - - public void createDataPizzaDoenerForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaDoener(), - }); - } - - public void createDataPizzaForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener(), - }); - } - - public void createDataSoupForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectSoupChicken(), - objectSoupBeautiful(), - }); - } - - public void createDataFoodForTenants(WeaviateClient client, String... tenants) { - createDataForTenants(client, tenants, () -> new WeaviateObject[]{ - objectPizzaQuattroFormaggi(), - objectPizzaFruttiDiMare(), - objectPizzaHawaii(), - objectPizzaDoener(), - objectSoupChicken(), - objectSoupBeautiful(), - }); - } - - private void createDataForTenants(WeaviateClient client, String[] tenants, Supplier objectsSupplier) { - WeaviateObject[] objects = Arrays.stream(tenants).flatMap(tenant -> - Arrays.stream(objectsSupplier.get()).peek(obj -> obj.setTenant(tenant)) - ).toArray(WeaviateObject[]::new); - - createData(client, objects); - } - - private WeaviateClass classPizza() { - return classPizzaBuilder() - .build(); - } - - private WeaviateClass classPizzaForTenants() { - return classPizzaBuilder() - .multiTenancyConfig(MultiTenancyConfig.builder() - .enabled(true) - .build()) - .build(); - } - - private WeaviateClass.WeaviateClassBuilder classPizzaBuilder() { - return WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .properties(classPropertiesFood()) - .invertedIndexConfig(InvertedIndexConfig.builder() - .indexTimestamps(true) - .build()); - } - - private WeaviateClass classSoup() { - return classSoupBuilder() - .build(); - } - - private WeaviateClass classSoupForTenants() { - return classSoupBuilder() - .multiTenancyConfig(MultiTenancyConfig.builder() - .enabled(true) - .build()) - .build(); - } - - private WeaviateClass.WeaviateClassBuilder classSoupBuilder() { - return WeaviateClass.builder() - .className("Soup") - .description("Mostly water based brew of sustenance for humans.") - .properties(classPropertiesFood()); - } - - private List classPropertiesFood() { - Property nameProperty = Property.builder() - .name("name") - .description("property holding name") - .dataType(Collections.singletonList(DataType.TEXT)) - .tokenization(Tokenization.FIELD) - .build(); - Property descriptionProperty = Property.builder() - .name("description") - .description("property holding description") - .dataType(Collections.singletonList(DataType.TEXT)) - .tokenization(Tokenization.WORD) - .build(); - Property bestBeforeProperty = Property.builder() - .name("bestBefore") - .description("property holding best before") - .dataType(Collections.singletonList(DataType.DATE)) - .build(); - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("skip", true); - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - Property priceProperty = Property.builder() - .name("price") - .description("property holding price") - .dataType(Collections.singletonList(DataType.NUMBER)) - .moduleConfig(moduleConfig) - .build(); - - List properties = new ArrayList<>(); - properties.add(nameProperty); - properties.add(descriptionProperty); - properties.add(bestBeforeProperty); - properties.add(priceProperty); - - return properties; - } - - private WeaviateObject objectPizzaQuattroFormaggi() { - return createObject(PIZZA_QUATTRO_FORMAGGI_ID, "Pizza", "Quattro Formaggi", - "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.", - 1.4f, "2022-01-02T03:04:05+01:00"); - } - - private WeaviateObject objectPizzaFruttiDiMare() { - return createObject(PIZZA_FRUTTI_DI_MARE_ID, "Pizza", "Frutti di Mare", - "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.", - 2.5f, "2022-02-03T04:05:06+02:00"); - } - - private WeaviateObject objectPizzaHawaii() { - return createObject(PIZZA_HAWAII_ID, "Pizza", "Hawaii", - "Universally accepted to be the best pizza ever created.", - 1.1f, "2022-03-04T05:06:07+03:00"); - } - - private WeaviateObject objectPizzaDoener() { - return createObject(PIZZA_DOENER_ID, "Pizza", "Doener", - "A innovation, some say revolution, in the pizza industry.", - 1.2f, "2022-04-05T06:07:08+04:00"); - } - - private WeaviateObject objectSoupChicken() { - return createObject(SOUP_CHICKENSOUP_ID, "Soup", "ChickenSoup", - "Used by humans when their inferior genetics are attacked by microscopic organisms.", - 2.0f, "2022-05-06T07:08:09+05:00"); - } - - private WeaviateObject objectSoupBeautiful() { - return createObject(SOUP_BEAUTIFUL_ID, "Soup", "Beautiful", - "Putting the game of letter soups to a whole new level.", - 3f, "2022-06-07T08:09:10+06:00"); - } - - - public static class DocumentPassageSchema { - - public final String DOCUMENT = "Document"; - public final String[] DOCUMENT_IDS = new String[]{ - "00000000-0000-0000-0000-00000000000a", - "00000000-0000-0000-0000-00000000000b", - "00000000-0000-0000-0000-00000000000c", - "00000000-0000-0000-0000-00000000000d", - }; - public final String PASSAGE = "Passage"; - public final String[] PASSAGE_IDS = new String[]{ - "00000000-0000-0000-0000-000000000001", - "00000000-0000-0000-0000-000000000002", - "00000000-0000-0000-0000-000000000003", - "00000000-0000-0000-0000-000000000004", - "00000000-0000-0000-0000-000000000005", - "00000000-0000-0000-0000-000000000006", - "00000000-0000-0000-0000-000000000007", - "00000000-0000-0000-0000-000000000008", - "00000000-0000-0000-0000-000000000009", - "00000000-0000-0000-0000-000000000010", - "00000000-0000-0000-0000-000000000011", - "00000000-0000-0000-0000-000000000012", - "00000000-0000-0000-0000-000000000013", - "00000000-0000-0000-0000-000000000014", - "00000000-0000-0000-0000-000000000015", - "00000000-0000-0000-0000-000000000016", - "00000000-0000-0000-0000-000000000017", - "00000000-0000-0000-0000-000000000018", - "00000000-0000-0000-0000-000000000019", - "00000000-0000-0000-0000-000000000020" - }; - - private void createDocumentClass(WeaviateClient client) { - Property titleProperty = Property.builder() - .dataType(Collections.singletonList(DataType.TEXT)) - .name("title") - .tokenization(Tokenization.FIELD) - .build(); - WeaviateClass document = WeaviateClass.builder() - .className(DOCUMENT) - .properties(Collections.singletonList(titleProperty)) - .invertedIndexConfig(InvertedIndexConfig.builder().indexTimestamps(true).build()) - .build(); - Result documentCreateStatus = client.schema().classCreator().withClass(document).run(); - assertNotNull(documentCreateStatus); - assertTrue(documentCreateStatus.getResult()); - } - - private void createPassageClass(WeaviateClient client) { - Property contentProperty = Property.builder() - .dataType(Collections.singletonList(DataType.TEXT)) - .name("content") - .tokenization(Tokenization.FIELD) - .build(); - Property typeProperty = Property.builder() - .dataType(Collections.singletonList(DataType.TEXT)) - .name("type") - .tokenization(Tokenization.FIELD) - .build(); - Property ofDocumentProperty = Property.builder() - .dataType(Collections.singletonList(DOCUMENT)) - .name("ofDocument") - .build(); - WeaviateClass document = WeaviateClass.builder() - .className(PASSAGE) - .properties(Arrays.asList(contentProperty, typeProperty, ofDocumentProperty)) - .invertedIndexConfig(InvertedIndexConfig.builder().indexTimestamps(true).build()) - .build(); - Result documentCreateStatus = client.schema().classCreator().withClass(document).run(); - assertNotNull(documentCreateStatus); - assertTrue(documentCreateStatus.getResult()); - } - - private void insertData(WeaviateClient client) { - WeaviateObject[] documents = new WeaviateObject[DOCUMENT_IDS.length]; - for (int i = 0; i < DOCUMENT_IDS.length; i++) { - String title = String.format("Title of the document %s", i); - WeaviateObject document = WeaviateObject.builder() - .id(DOCUMENT_IDS[i]) - .className(DOCUMENT) - .properties(new HashMap() {{ - put("title", title); - }}).build(); - documents[i] = document; - } - WeaviateObject[] passages = new WeaviateObject[PASSAGE_IDS.length]; - for (int i = 0; i < PASSAGE_IDS.length; i++) { - String content = String.format("Passage content %s", i); - WeaviateObject passage = WeaviateObject.builder() - .id(PASSAGE_IDS[i]) - .className(PASSAGE) - .properties(new HashMap() {{ - put("content", content); - put("type", "document-passage"); - }}).build(); - passages[i] = passage; - } - Result insertStatus = client.batch().objectsBatcher() - .withObjects(documents) - .withObjects(passages) - .run(); - assertNotNull(insertStatus); - assertNull(insertStatus.getError()); - assertNotNull(insertStatus.getResult()); - // first 10 passages assign to document 1 - createReferences(client, documents[0], Arrays.copyOfRange(passages, 0, 10)); - // next 4 passages assign to document 2 - createReferences(client, documents[1], Arrays.copyOfRange(passages, 10, 14)); - } - - private void createReferences(WeaviateClient client, WeaviateObject document, WeaviateObject[] passages) { - SingleRef ref = client.data().referencePayloadBuilder() - .withID(document.getId()).withClassName(DOCUMENT).payload(); - for (WeaviateObject passage : passages) { - Result createOfDocumentRef = client.data().referenceCreator() - .withID(passage.getId()) - .withClassName(PASSAGE) - .withReferenceProperty("ofDocument") - .withReference(ref) - .run(); - assertNotNull(createOfDocumentRef); - assertNull(createOfDocumentRef.getError()); - assertTrue(createOfDocumentRef.getResult()); - } - } - - public void createSchema(WeaviateClient client) { - createDocumentClass(client); - createPassageClass(client); - } - - public void createAndInsertData(WeaviateClient client) { - createSchema(client); - insertData(client); - } - - public void cleanupWeaviate(WeaviateClient client) { - Result deleteAllStatus = client.schema().allDeleter().run(); - assertNotNull(deleteAllStatus); - assertTrue(deleteAllStatus.getResult()); - } - } - - public static class AllPropertiesSchema { - - public String REF_CLASS = "RefClass"; - public String REF_CLASS_CATEGORY_PROPERTY = "category"; - public String REF_CLASS_CATEGORY_PROPERTY_TYPE = DataType.TEXT; - public String REF_CLASS2 = "RefClass2"; - public String REF_CLASS2_CATEGORY_PROPERTY = REF_CLASS_CATEGORY_PROPERTY; - public String REF_CLASS2_CATEGORY_PROPERTY_TYPE = REF_CLASS_CATEGORY_PROPERTY_TYPE; - public String CLASS_NAME = "AllProperties"; - public String HAS_REF_PROP = "hasRefProp"; - public String HAS_REF_PROP2 = "hasRefProp2"; - - public String REF_ID1 = "a0000000-0000-0000-0000-000000000001"; - public String REF_ID2 = "a0000000-0000-0000-0000-000000000002"; - public String REF_ID3 = "a0000000-0000-0000-0000-000000000003"; - public String[] REF_IDS = new String[] { - REF_ID1, REF_ID2, REF_ID3 - }; - public String[] REF2_IDS = new String[] { - REF_ID1, REF_ID2, REF_ID3 - }; - - private void createClass(WeaviateClient client) { - Result createResult = client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(CLASS_NAME) - .properties(properties()) - .build() - ) - .run(); - - assertThat(createResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - public List properties() { - return Arrays.asList( - Property.builder() - .name("bool") - .dataType(Collections.singletonList(DataType.BOOLEAN)) - .build(), - Property.builder() - .name("bools") - .dataType(Collections.singletonList(DataType.BOOLEAN_ARRAY)) - .build(), - - Property.builder() - .name("int") - .dataType(Collections.singletonList(DataType.INT)) - .build(), - Property.builder() - .name("ints") - .dataType(Collections.singletonList(DataType.INT_ARRAY)) - .build(), - - Property.builder() - .name("number") - .dataType(Collections.singletonList(DataType.NUMBER)) - .build(), - Property.builder() - .name("numbers") - .dataType(Collections.singletonList(DataType.NUMBER_ARRAY)) - .build(), - - Property.builder() - .name("string") - .dataType(Collections.singletonList(DataType.STRING)) - .build(), - Property.builder() - .name("strings") - .dataType(Collections.singletonList(DataType.STRING_ARRAY)) - .build(), - - Property.builder() - .name("text") - .dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder() - .name("texts") - .dataType(Collections.singletonList(DataType.TEXT_ARRAY)) - .build(), - - Property.builder() - .name("date") - .dataType(Collections.singletonList(DataType.DATE)) - .build(), - Property.builder() - .name("dates") - .dataType(Collections.singletonList(DataType.DATE_ARRAY)) - .build(), - - Property.builder() - .name("uuid") - .dataType(Collections.singletonList(DataType.UUID)) - .build(), - Property.builder() - .name("uuids") - .dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .build() - ); - } - - public List propertiesWithCrossReference() { - Property hasRefProperty = Property.builder() - .name(HAS_REF_PROP) - .dataType(Collections.singletonList(REF_CLASS)) - .build(); - List props = new ArrayList<>(properties()); - props.add(hasRefProperty); - return props; - } - - public List propertiesWithMultiCrossReference() { - Property hasRefProperty = Property.builder() - .name(HAS_REF_PROP2) - .dataType(Arrays.asList(REF_CLASS, REF_CLASS2)) - .build(); - List props = new ArrayList<>(propertiesWithCrossReference()); - props.add(hasRefProperty); - return props; - } - - public List propertiesWithNestedObject() { - Property objectProperty = Property.builder() - .name("objectProperty") - .dataType(Collections.singletonList(DataType.OBJECT)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("firstName") - .dataType(Arrays.asList(DataType.TEXT)) - .build() - )) - .build(); - List props = new ArrayList<>(properties()); - props.add(objectProperty); - return props; - } - - public List propertiesWithNestedObjectAndNestedArrayObject() { - Property objectArrayProperty = Property.builder() - .name("objectArrayProperty") - .dataType(Collections.singletonList(DataType.OBJECT_ARRAY)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("firstName") - .dataType(Arrays.asList(DataType.TEXT)) - .build() - )) - .build(); - List props = new ArrayList<>(propertiesWithNestedObject()); - props.add(objectArrayProperty); - return props; - } - - public List propertiesWithCrossReferenceWithNestedProperties() { - Property hasRefProperty = Property.builder() - .name(HAS_REF_PROP) - .dataType(Collections.singletonList(REF_CLASS)) - .build(); - List props = new ArrayList<>(propertiesWithNestedObjectAndNestedArrayObject()); - props.add(hasRefProperty); - return props; - } - - public List propertiesWithMultiCrossReferenceWithNestedProperties() { - Property hasRefProperty2 = Property.builder() - .name(HAS_REF_PROP2) - .dataType(Arrays.asList(REF_CLASS, REF_CLASS2)) - .build(); - List props = new ArrayList<>(propertiesWithCrossReferenceWithNestedProperties()); - props.add(hasRefProperty2); - return props; - } - - public void createRefClassesWithObjects(WeaviateClient client) { - createRefClasses(client); - createRefClassObjects(client, REF_CLASS, REF_CLASS_CATEGORY_PROPERTY); - createRefClassObjects(client, REF_CLASS2, REF_CLASS2_CATEGORY_PROPERTY); - } - - public void deleteRefClasses(WeaviateClient client) { - // clean up - Stream.of(REF_CLASS, REF_CLASS2).forEach(className -> { - Result delete = client.schema().classDeleter().withClassName(className).run(); - assertThat(delete).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isEqualTo(Boolean.TRUE); - }); - } - - private void createRefClasses(WeaviateClient client) { - createRefClasses(client, REF_CLASS, REF_CLASS_CATEGORY_PROPERTY, REF_CLASS_CATEGORY_PROPERTY_TYPE); - createRefClasses(client, REF_CLASS2, REF_CLASS2_CATEGORY_PROPERTY, REF_CLASS2_CATEGORY_PROPERTY_TYPE); - } - - private void createRefClasses(WeaviateClient client, String className, String propertyName, String propertyType) { - WeaviateClass refClass = WeaviateClass.builder() - .className(className) - .properties(Collections.singletonList( - Property.builder() - .name(propertyName) - .dataType(Collections.singletonList(propertyType)) - .build() - )) - .build(); - - Result result = client.schema().classCreator() - .withClass(refClass) - .run(); - - assertThat(result).isNotNull() - .withFailMessage(() -> result.getError().toString()) - .returns(false, Result::hasErrors) - .withFailMessage(null) - .returns(true, Result::getResult); - } - - private void createRefClassObjects(WeaviateClient client, String className, String propertyName) { - String[] refIds = REF_IDS; - String[] categories = new String[]{ - "science-fiction", "fantasy", "novel", - }; - - WeaviateObject[] objects = IntStream.range(0, refIds.length).mapToObj(i -> { - Map props = new HashMap<>(); - props.put(propertyName, categories[i]); - - return WeaviateObject.builder() - .className(className) - .id(refIds[i]) - .properties(props) - .build(); - } - ).toArray(WeaviateObject[]::new); - - Result result = client.batch().objectsBatcher() - .withObjects(objects) - .run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(objects.length); - } - - public WeaviateObject[] objects() { - String id1 = "00000000-0000-0000-0000-000000000001"; - String id2 = "00000000-0000-0000-0000-000000000002"; - String id3 = "00000000-0000-0000-0000-000000000003"; - - TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC)); - Calendar cal1 = Calendar.getInstance(); - cal1.set(2023, Calendar.JANUARY, 15, 17, 1, 2); - Date date1 = cal1.getTime(); - Calendar cal2 = Calendar.getInstance(); - cal2.set(2023, Calendar.FEBRUARY, 15, 17, 1, 2); - Date date2 = cal2.getTime(); - Calendar cal3 = Calendar.getInstance(); - cal3.set(2023, Calendar.MARCH, 15, 17, 1, 2); - Date date3 = cal3.getTime(); - - String[] ids = new String[]{ - id1, id2, id3 - }; - Boolean[] bools = new Boolean[]{ - true, false, true - }; - Boolean[][] boolsArray = new Boolean[][]{ - {true, false, true}, - {true, false}, - {true}, - }; - Integer[] ints = new Integer[]{ - 1, 2, 3 - }; - Integer[][] intsArray = new Integer[][]{ - {1, 2, 3}, - {1, 2}, - {1}, - }; - Double[] numbers = new Double[]{ - 1.1, 2.2, 3.3 - }; - Double[][] numbersArray = new Double[][]{ - {1.1, 2.2, 3.3}, - {1.1, 2.2}, - {1.1}, - }; - String[] strings = new String[]{ - "string1", "string2", "string3" - }; - String[][] stringsArray = new String[][]{ - {"string1", "string2", "string3"}, - {"string1", "string2"}, - {"string1"}, - }; - String[] texts = new String[]{ - "text1", "text2", "text3" - }; - String[][] textsArray = new String[][]{ - {"text1", "text2", "text3"}, - {"text1", "text2"}, - {"text1"}, - }; - Date[] dates = new Date[]{ - date1, date2, date3 - }; - Date[][] datesArray = new Date[][]{ - {date1, date2, date3}, - {date1, date2}, - {date1}, - }; - String[] uuids = new String[]{ - id1, id2, id3 - }; - String[][] uuidsArray = new String[][]{ - {id1, id2, id3}, - {id1, id2}, - {id1}, - }; - - Function formatDate = date -> DateFormatUtils.format(date, "yyyy-MM-dd'T'HH:mm:ssZZZZZ"); - - WeaviateObject[] objects = IntStream.range(0, ids.length).mapToObj(i -> { - Map props = new HashMap<>(); - props.put("bool", bools[i]); - props.put("bools", boolsArray[i]); - props.put("int", ints[i]); - props.put("ints", intsArray[i]); - props.put("number", numbers[i]); - props.put("numbers", numbersArray[i]); - props.put("string", strings[i]); - props.put("strings", stringsArray[i]); - props.put("text", texts[i]); - props.put("texts", textsArray[i]); - props.put("date", formatDate.apply(dates[i])); - props.put("dates", Arrays.stream(datesArray[i]).map(formatDate).toArray(String[]::new)); - props.put("uuid", uuids[i]); - props.put("uuids", uuidsArray[i]); - - return WeaviateObject.builder() - .className(CLASS_NAME) - .id(ids[i]) - .properties(props) - .build(); - } - ).toArray(WeaviateObject[]::new); - - return objects; - } - - private final List> createBeacon(String className, String id) { - Map refProperty = new HashMap<>(); - refProperty.put("beacon", String.format("weaviate://localhost/%s/%s", className, id)); - return Collections.singletonList(refProperty); - } - - private final List> createMultiRefBeacon(String className, String id, String className2, String id2) { - Map refProperty = new HashMap<>(); - refProperty.put("beacon", String.format("weaviate://localhost/%s/%s", className, id)); - Map refProperty2 = new HashMap<>(); - refProperty2.put("beacon", String.format("weaviate://localhost/%s/%s", className2, id2)); - return Arrays.asList(refProperty, refProperty2); - } - - private WeaviateObject[] objectsWithCrossReferences(WeaviateObject[] objects) { - IntStream.range(0, objects.length) - .forEach(i -> { - objects[i].getProperties().put(HAS_REF_PROP, createBeacon(REF_CLASS, REF_IDS[0])); - }); - return objects; - } - - private WeaviateObject[] objectsWithMultiCrossReferences(WeaviateObject[] objects) { - IntStream.range(0, objects.length) - .forEach(i -> { - objects[i].getProperties().put(HAS_REF_PROP2, createMultiRefBeacon(REF_CLASS, REF_IDS[1], REF_CLASS2, REF2_IDS[2])); - }); - return objects; - } - - public WeaviateObject[] objectsWithCrossReferences() { - return objectsWithCrossReferences(objects()); - } - - public WeaviateObject[] objectsWithMultiCrossReferences() { - return objectsWithMultiCrossReferences(objectsWithCrossReferences()); - } - - public WeaviateObject[] objectsWithNestedObject() { - try { - File jsonFile = new File("src/test/resources/json/nested-one-object.json"); - InputStreamReader reader = new InputStreamReader(Files.newInputStream(jsonFile.toPath())); - final Object nestedOneObject = new Gson().fromJson(reader, Object.class); - WeaviateObject[] objects = objects(); - Arrays.stream(objects).forEach(obj -> { - obj.getProperties().put("objectProperty", nestedOneObject); - }); - return objects; - } catch (IOException e) { - throw new RuntimeException(e); - } - } - - public WeaviateObject[] objectsWithNestedObjectAndNestedArrayObject() { - try { - File jsonFile = new File("src/test/resources/json/nested-array-object.json"); - InputStreamReader reader = new InputStreamReader(Files.newInputStream(jsonFile.toPath())); - final Object nestedArrayObject = new Gson().fromJson(reader, Object.class); - WeaviateObject[] objects = objectsWithNestedObject(); - Arrays.stream(objects).forEach(obj -> { - obj.getProperties().put("objectArrayProperty", nestedArrayObject); - }); - return objects; - } catch (IOException e) { - throw new RuntimeException(e); - } - } - - public WeaviateObject[] objectsWithCrossReferencesWithNestedProperties() { - return objectsWithCrossReferences(objectsWithNestedObjectAndNestedArrayObject()); - } - - public WeaviateObject[] objectsWithMultiCrossReferencesWithNestedProperties() { - return objectsWithMultiCrossReferences(objectsWithCrossReferencesWithNestedProperties()); - } - } - - public DocumentPassageSchema documentPassageSchema() { - return new DocumentPassageSchema(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java b/src/test/java/io/weaviate/integration/client/WeaviateVersion.java deleted file mode 100644 index 6f5a26294..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateVersion.java +++ /dev/null @@ -1,15 +0,0 @@ -package io.weaviate.integration.client; - -public class WeaviateVersion { - - // docker image version - public static final String WEAVIATE_IMAGE = "1.33.0-rc.0"; - - // to be set according to weaviate docker image - public static final String EXPECTED_WEAVIATE_VERSION = "1.33.0-rc.0"; - // to be set according to weaviate docker image - public static final String EXPECTED_WEAVIATE_GIT_HASH = "15c08c7"; - - private WeaviateVersion() { - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateWithAzureContainer.java b/src/test/java/io/weaviate/integration/client/WeaviateWithAzureContainer.java deleted file mode 100644 index 950ca1c5a..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateWithAzureContainer.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.integration.client; - -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateWithAzureContainer extends WeaviateContainer { - - public WeaviateWithAzureContainer(String dockerImageName) { - super(dockerImageName); - - waitingFor(Wait.forHttp("/v1/.well-known/openid-configuration").forPort(8080).forStatusCode(200)); - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "4706508f-30c2-469b-8b12-ad272b3de864"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://login.microsoftonline.com/36c47fb4-f57c-4e1c-8760-d42293932cc2/v2.0"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "oid"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - withEnv("AUTHORIZATION_ADMINLIST_ENABLED", "true"); - withEnv("AUTHORIZATION_ADMINLIST_USERS", "b6bf8e1d-d398-4e5d-8f1b-50fda9146a64"); - withEnv("AUTHENTICATION_OIDC_SCOPES", ""); - withEnv("DISABLE_TELEMETRY", "true"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateWithOidcContainer.java b/src/test/java/io/weaviate/integration/client/WeaviateWithOidcContainer.java deleted file mode 100644 index 8a123a416..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateWithOidcContainer.java +++ /dev/null @@ -1,26 +0,0 @@ -package io.weaviate.integration.client; - -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateWithOidcContainer extends WeaviateContainer { - - public WeaviateWithOidcContainer(String dockerImageName) { - super(dockerImageName); - - waitingFor(Wait.forHttp("/v1/.well-known/openid-configuration").forPort(8080).forStatusCode(200)); - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "wcs"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://auth.wcs.api.weaviate.io/auth/realms/SeMI"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "email"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - withEnv("AUTHORIZATION_ADMINLIST_ENABLED", "true"); - withEnv("AUTHORIZATION_ADMINLIST_USERS", "oidc-test-user@weaviate.io"); - withEnv("AUTHENTICATION_OIDC_SCOPES", "openid,email"); - withEnv("AUTHENTICATION_APIKEY_ENABLED", "true"); - withEnv("AUTHENTICATION_APIKEY_ALLOWED_KEYS", "my-secret-key"); - withEnv("AUTHENTICATION_APIKEY_USERS", "oidc-test-user@weaviate.io"); - withEnv("DISABLE_TELEMETRY", "true"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateWithOktaCcContainer.java b/src/test/java/io/weaviate/integration/client/WeaviateWithOktaCcContainer.java deleted file mode 100644 index b4bb58c6c..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateWithOktaCcContainer.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.integration.client; - -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateWithOktaCcContainer extends WeaviateContainer { - - public WeaviateWithOktaCcContainer(String dockerImageName) { - super(dockerImageName); - - waitingFor(Wait.forHttp("/v1/.well-known/openid-configuration").forPort(8080).forStatusCode(200)); - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "0oa7e9ipdkVZRUcxo5d7"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://dev-32300990.okta.com/oauth2/aus7e9kxbwYQB0eht5d7"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "cid"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - withEnv("AUTHORIZATION_ADMINLIST_ENABLED", "true"); - withEnv("AUTHORIZATION_ADMINLIST_USERS", "0oa7e9ipdkVZRUcxo5d7"); - withEnv("AUTHENTICATION_OIDC_SCOPES", ""); - withEnv("DISABLE_TELEMETRY", "true"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateWithOktaUsersContainer.java b/src/test/java/io/weaviate/integration/client/WeaviateWithOktaUsersContainer.java deleted file mode 100644 index 8a4e1e43c..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateWithOktaUsersContainer.java +++ /dev/null @@ -1,23 +0,0 @@ -package io.weaviate.integration.client; - -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateWithOktaUsersContainer extends WeaviateContainer { - - public WeaviateWithOktaUsersContainer(String dockerImageName) { - super(dockerImageName); - - waitingFor(Wait.forHttp("/v1/.well-known/openid-configuration").forPort(8080).forStatusCode(200)); - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "0oa7iz2g41rNxv95B5d7"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://dev-32300990.okta.com/oauth2/aus7iz3tna3kckRWS5d7"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "sub"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - withEnv("AUTHORIZATION_ADMINLIST_ENABLED", "true"); - withEnv("AUTHORIZATION_ADMINLIST_USERS", "test@test.de"); - withEnv("AUTHENTICATION_OIDC_SCOPES", "openid,email"); - withEnv("DISABLE_TELEMETRY", "true"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/WeaviateWithRbacContainer.java b/src/test/java/io/weaviate/integration/client/WeaviateWithRbacContainer.java deleted file mode 100644 index 880f291a8..000000000 --- a/src/test/java/io/weaviate/integration/client/WeaviateWithRbacContainer.java +++ /dev/null @@ -1,41 +0,0 @@ -package io.weaviate.integration.client; - -import org.testcontainers.weaviate.WeaviateContainer; - -public class WeaviateWithRbacContainer extends WeaviateContainer { - - public WeaviateWithRbacContainer(String dockerImageName, String admin, String... viewers) { - super(dockerImageName); - - withEnv("AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED", "false"); - withEnv("AUTHENTICATION_APIKEY_ENABLED", "true"); - withEnv("AUTHORIZATION_RBAC_ENABLED", "true"); - withEnv("AUTHENTICATION_APIKEY_ALLOWED_KEYS", makeSecret(admin)); - withEnv("AUTHENTICATION_APIKEY_USERS", admin); - withEnv("AUTHORIZATION_ADMIN_USERS", admin); - withEnv("PERSISTENCE_DATA_PATH", "./data"); - withEnv("BACKUP_FILESYSTEM_PATH", "/tmp/backups"); - withEnv("ENABLE_MODULES", "backup-filesystem"); - withEnv("CLUSTER_GOSSIP_BIND_PORT", "7100"); - withEnv("CLUSTER_DATA_BIND_PORT", "7101"); - withEnv("AUTHENTICATION_DB_USERS_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_ENABLED", "true"); - withEnv("AUTHENTICATION_OIDC_CLIENT_ID", "wcs"); - withEnv("AUTHENTICATION_OIDC_ISSUER", "https://auth.wcs.api.weaviate.io/auth/realms/SeMI"); - withEnv("AUTHENTICATION_OIDC_USERNAME_CLAIM", "email"); - withEnv("AUTHENTICATION_OIDC_GROUPS_CLAIM", "groups"); - if (viewers.length > 0) { - withEnv("AUTHORIZATION_VIEWER_USERS", String.join(",", viewers)); - } - } - - /** - * Generate API secret for a username. When running an instance with - * authentication enabled, {@link WeaviateWithRbacContainer} will use this - * method to generate secrets for all users. - * Use this method to get a valid API key for a test client. - */ - public static String makeSecret(String user) { - return user + "-secret"; - } -} diff --git a/src/test/java/io/weaviate/integration/client/aliases/ClientAliasesTest.java b/src/test/java/io/weaviate/integration/client/aliases/ClientAliasesTest.java deleted file mode 100644 index 83f0f96d2..000000000 --- a/src/test/java/io/weaviate/integration/client/aliases/ClientAliasesTest.java +++ /dev/null @@ -1,92 +0,0 @@ -package io.weaviate.integration.client.aliases; - -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.HashMap; -import java.util.Map; - -import org.assertj.core.api.Assertions; -import org.assertj.core.api.InstanceOfAssertFactories; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; - -public class ClientAliasesTest { - private WeaviateClient client; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @Test - public void shouldManageAliases() { - // Arrange - Result createdPaul = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("PaulHewson").build()).run(); - assumeTrue(createdPaul.getResult(), "created PaulHewson collection"); - - Result createdGeorge = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("GeorgeBarnes").build()).run(); - assumeTrue(createdGeorge.getResult(), "created GeorgeBarnes collection"); - - // Act: create alias - client.alias().creator().withClassName("PaulHewson").withAlias("Bono").run(); - client.alias().creator().withClassName("GeorgeBarnes").withAlias("MachineGunKelly").run(); - - // Assert: get all - Result> all = client.alias().allGetter().run(); - - Assertions.assertThat(all.getError()).isNull(); - Assertions.assertThat(all.getResult()) - .as("fetched all aliases") - .containsAllEntriesOf(new HashMap() { - { - put("Bono", new Alias("PaulHewson", "Bono")); - put("MachineGunKelly", new Alias("GeorgeBarnes", "MachineGunKelly")); - } - }); - - // Act: update - Result createdMGK = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("ColsonBaker").build()).run(); - assumeTrue(createdMGK.getResult(), "created ColsonBaker collection"); - - client.alias().updater().withAlias("MachineGunKelly").withNewClassName("ColsonBaker").run(); - - // Assert: get one - Result mgk = client.alias().getter().withAlias("MachineGunKelly").run(); - - Assertions.assertThat(mgk.getResult()) - .as("MachineGunKelly alias points to ColsonBaker") - .returns("MachineGunKelly", Alias::getAlias) - .returns("ColsonBaker", Alias::getClassName); - - Result> colsonAliases = client.alias().allGetter().withClassName("ColsonBaker").run(); - Assertions.assertThat(colsonAliases.getResult()) - .containsOnlyKeys("MachineGunKelly") - .extracting(Map::values, InstanceOfAssertFactories.collection(Alias.class)) - .extracting(Alias::getClassName).containsOnly("ColsonBaker"); - - // Act: delete - client.alias().deleter().withAlias("Bono").run(); - - // Assert - Result bono = client.alias().getter().withAlias("Bono").run(); - Assertions.assertThat(bono) - .as("Bono alias deleted") - .returns(null, Result::getResult) - .extracting(Result::getError).isNull(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/aliases/ClientAliasesTest.java b/src/test/java/io/weaviate/integration/client/async/aliases/ClientAliasesTest.java deleted file mode 100644 index 9a071151a..000000000 --- a/src/test/java/io/weaviate/integration/client/async/aliases/ClientAliasesTest.java +++ /dev/null @@ -1,100 +0,0 @@ -package io.weaviate.integration.client.async.aliases; - -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.ExecutionException; - -import org.assertj.core.api.Assertions; -import org.assertj.core.api.InstanceOfAssertFactories; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; - -public class ClientAliasesTest { - private WeaviateAsyncClient client; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config).async(); - } - - @After - public void after() { - client.close(); - } - - @Test - public void shouldManageAliases() throws InterruptedException, ExecutionException { - // Arrange - Result createdPaul = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("PaulHewson").build()).run().get(); - assumeTrue(createdPaul.getResult(), "created PaulHewson collection"); - - Result createdGeorge = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("GeorgeBarnes").build()).run().get(); - assumeTrue(createdGeorge.getResult(), "created GeorgeBarnes collection"); - - // Act: create alias - client.alias().creator().withClassName("PaulHewson").withAlias("Bono").run().get(); - client.alias().creator().withClassName("GeorgeBarnes").withAlias("MachineGunKelly").run().get(); - - // Assert: get all - Result> all = client.alias().allGetter().run().get(); - - Assertions.assertThat(all.getError()).isNull(); - Assertions.assertThat(all.getResult()) - .as("fetched all aliases") - .containsAllEntriesOf(new HashMap() { - { - put("Bono", new Alias("PaulHewson", "Bono")); - put("MachineGunKelly", new Alias("GeorgeBarnes", "MachineGunKelly")); - } - }); - - // Act: update - Result createdMGK = client.schema().classCreator().withClass(WeaviateClass.builder() - .className("ColsonBaker").build()).run().get(); - assumeTrue(createdMGK.getResult(), "created ColsonBaker collection"); - - client.alias().updater().withAlias("MachineGunKelly").withNewClassName("ColsonBaker").run().get(); - - // Assert: get one - Result mgk = client.alias().getter().withAlias("MachineGunKelly").run().get(); - - Assertions.assertThat(mgk.getResult()) - .as("MachineGunKelly alias points to ColsonBaker") - .returns("MachineGunKelly", Alias::getAlias) - .returns("ColsonBaker", Alias::getClassName); - - Result> colsonAliases = client.alias().allGetter().withClassName("ColsonBaker").run().get(); - Assertions.assertThat(colsonAliases.getResult()) - .containsOnlyKeys("MachineGunKelly") - .extracting(Map::values, InstanceOfAssertFactories.collection(Alias.class)) - .extracting(Alias::getClassName).containsOnly("ColsonBaker"); - - // Act: delete - client.alias().deleter().withAlias("Bono").run().get(); - - // Assert - Result bono = client.alias().getter().withAlias("Bono").run().get(); - Assertions.assertThat(bono) - .as("Bono alias deleted") - .returns(null, Result::getResult) - .extracting(Result::getError).isNull(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/backup/ClientBackupTest.java b/src/test/java/io/weaviate/integration/client/async/backup/ClientBackupTest.java deleted file mode 100644 index 870620755..000000000 --- a/src/test/java/io/weaviate/integration/client/async/backup/ClientBackupTest.java +++ /dev/null @@ -1,723 +0,0 @@ -package io.weaviate.integration.client.async.backup; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -import org.assertj.core.api.Assertions; -import org.jetbrains.annotations.NotNull; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.backup.api.BackupCanceler; -import io.weaviate.client.v1.async.backup.api.BackupCreateStatusGetter; -import io.weaviate.client.v1.async.backup.api.BackupCreator; -import io.weaviate.client.v1.async.backup.api.BackupGetter; -import io.weaviate.client.v1.async.backup.api.BackupRestoreStatusGetter; -import io.weaviate.client.v1.async.backup.api.BackupRestorer; -import io.weaviate.client.v1.async.backup.api.BackupRestorer.BackupRestoreConfig; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; -import io.weaviate.client.v1.backup.model.RbacRestoreOption; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.rbac.model.ClusterPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerComposeBackup; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.backup.BackupTestSuite; - -public class ClientBackupTest { - - private String backupId; - private String notExistingBackupId; - private WeaviateClient client; - - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - private final static Random rand = new Random(); - - @Rule - public TestName currentTest = new TestName(); - - @ClassRule - public static WeaviateDockerComposeBackup compose = new WeaviateDockerComposeBackup(); - - @Before - public void before() throws AuthException { - Config config = new Config("http", compose.getHttpHostAddress()); - client = WeaviateAuthClient.apiKey(config, WeaviateDockerComposeBackup.ADMIN_KEY); - testGenerics.createTestSchemaAndData(client); - - backupId = String.format("backup-%s-%s", currentTest.getMethodName().toLowerCase(), - rand.nextInt(Integer.MAX_VALUE)); - notExistingBackupId = "not-existing-backup-" + backupId; - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateAndRestoreBackupWithWaiting() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testCreateAndRestoreBackupWithWaiting(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, - createSupplierDeletePizza(), createSupplierGQLOfClass(), backupId); - } - } - - @Test - public void shouldCreateAndRestoreBackupWithoutWaiting() throws InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testCreateAndRestoreBackupWithoutWaiting(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, - createSupplierDeletePizza(), createSupplierGQLOfClass(), backupId); - } - } - - @Test - public void shouldCreateAndRestoreBackupWithDynamicLocation() throws InterruptedException { - String bucket = "test-bucket"; // irrelevant for "filesystem" backend, here only to illustrate - String path = "/custom/backup/location"; - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(BackupCreator.BackupCreateConfig.builder().bucket(bucket).path(path).build())); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withBucket(bucket) - .withPath(path)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(BackupRestorer.BackupRestoreConfig.builder().bucket(bucket).path(path).build())); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withBucket(bucket) - .withPath(path)); - - BackupTestSuite.testCreateWithDynamicLocation(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, - createSupplierDeletePizza(), createSupplierGQLOfClass(), backupId, bucket, path); - } - } - - @Test - public void shouldCreateAndRestore1Of2Classes() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testCreateAndRestore1Of2Classes(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, - createSupplierDeletePizza(), createSupplierGQLOfClass(), backupId); - } - } - - @Test - public void shouldListCreatedBackups() { - try (WeaviateAsyncClient asyncClient = client.async()) { - List>> createSuppliers = new ArrayList>>() { - { - this.add(createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId + "-1") - .withWaitForCompletion(true))); - this.add(createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId + "-2") - .withWaitForCompletion(true))); - } - }; - - Supplier> supplierGetResult = createSupplierGet( - asyncClient, creator -> creator - .withBackend(BackupTestSuite.BACKEND)); - - BackupTestSuite.testListExistingBackups(createSuppliers, supplierGetResult); - } - } - - @Test - public void shouldFailOnCreateBackupOnNotExistingBackend() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnCreateBackupOnNotExistingBackend(supplierCreateResult); - } - } - - @Test - public void shouldFailOnCreateBackupStatusOnNotExistingBackend() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnCreateBackupStatusOnNotExistingBackend(supplierCreateStatusResult); - } - } - - @Test - public void shouldFailOnRestoreBackupFromNotExistingBackend() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnRestoreBackupFromNotExistingBackend(supplierRestoreResult); - } - } - - @Test - public void shouldFailOnCreateBackupForNotExistingClass() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnCreateBackupForNotExistingClass(supplierCreateResult); - } - } - - @Test - public void shouldFailOnRestoreBackupForExistingClass() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - - BackupTestSuite.testFailOnRestoreBackupForExistingClass(supplierCreateResult, supplierRestoreResult, backupId); - } - } - - @Test - public void shouldFailOnCreateOfExistingBackup() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - - BackupTestSuite.testFailOnCreateOfExistingBackup(supplierCreateResult, backupId); - } - } - - @Test - public void shouldFailOnCreateStatusOfNotExistingBackup() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(notExistingBackupId)); - - BackupTestSuite.testFailOnCreateStatusOfNotExistingBackup(supplierCreateStatusResult, notExistingBackupId); - } - } - - @Test - public void shouldFailOnRestoreOfNotExistingBackup() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(notExistingBackupId)); - - BackupTestSuite.testFailOnRestoreOfNotExistingBackup(supplierRestoreResult, notExistingBackupId); - } - } - - @Test - public void shouldFailOnRestoreBackupStatusOfNotStartedRestore() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnRestoreBackupStatusOfNotStartedRestore(supplierCreateResult, - supplierRestoreStatusResult, backupId); - } - } - - @Test - public void shouldFailOnCreateBackupForBothIncludeAndExcludeClasses() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withExcludeClassNames(BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - - BackupTestSuite.testFailOnCreateBackupForBothIncludeAndExcludeClasses(supplierCreateResult); - } - } - - @Test - public void shouldFailOnRestoreBackupForBothIncludeAndExcludeClasses() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA, BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true)); - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withExcludeClassNames(BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testFailOnRestoreBackupForBothIncludeAndExcludeClasses(supplierCreateResult, - supplierRestoreResult, - createSupplierDeletePizza()); - } - } - - @Test - public void shouldCreateAndRestoreBackupWithWaitingWithConfig() { - try (WeaviateAsyncClient asyncClient = client.async()) { - // config with too high value - Supplier> supplierCreateInvConfigResult = createSupplierCreate( - asyncClient, creator -> { - BackupCreator.BackupCreateConfig invCreateConfig = BackupCreator.BackupCreateConfig.builder() - .cpuPercentage(801) - .build(); - - creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(invCreateConfig) - .withWaitForCompletion(true); - }); - // valid config - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> { - BackupCreator.BackupCreateConfig createConfig = BackupCreator.BackupCreateConfig.builder() - .cpuPercentage(80) - .chunkSize(512) - .compressionLevel(BackupCreator.BackupCompression.BEST_SPEED) - .build(); - - creator - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(createConfig) - .withWaitForCompletion(true); - }); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - // config with too high value - Supplier> supplierRestoreInvConfigResult = createSupplierRestore( - asyncClient, restorer -> { - BackupRestorer.BackupRestoreConfig invRestoreConfig = BackupRestorer.BackupRestoreConfig.builder() - .cpuPercentage(90) - .build(); - - restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(invRestoreConfig) - .withWaitForCompletion(true); - }); - // valid config - Supplier> supplierRestoreResult = createSupplierRestore( - asyncClient, restorer -> { - BackupRestorer.BackupRestoreConfig restoreConfig = BackupRestorer.BackupRestoreConfig.builder() - .cpuPercentage(70) - .build(); - - restorer - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(restoreConfig) - .withWaitForCompletion(true); - }); - Supplier> supplierRestoreStatusResult = createSupplierRestoreStatus( - asyncClient, restoreStatusGetter -> restoreStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testCreateAndRestoreBackupWithWaitingWithConfig(supplierCreateInvConfigResult, - supplierCreateResult, - supplierCreateStatusResult, supplierRestoreInvConfigResult, supplierRestoreResult, - supplierRestoreStatusResult, - createSupplierDeletePizza(), createSupplierGQLOfClass(), backupId); - } - } - - @Test - public void shouldCancelBackup() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierCreateResult = createSupplierCreate( - asyncClient, creator -> creator - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(false) // this will allow us to "intercept" the backup in progress - ); - Supplier> supplierCancelResult = createSupplierCanceler( - asyncClient, canceler -> canceler - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - Supplier> supplierCreateStatusResult = createSupplierCreateStatus( - asyncClient, createStatusGetter -> createStatusGetter - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId)); - - BackupTestSuite.testCancelBackup(supplierCreateResult, supplierCancelResult, supplierCreateStatusResult); - } - } - - @Test - public void shouldRestoreWithRbacOptions() { - final String className = "RolesUsers"; - final String roleName = "restoreRole"; - final String userName = "restoreUser"; - - try (final WeaviateAsyncClient async = client.async()) { - - BackupTestSuite.testBackupRestoreWithRbacOptions(backupId, - // Arrange: create collection, create role, create user; - runnable(() -> { - async.schema().classDeleter().withClassName(className).run().get(); - async.schema().classCreator().withClass(WeaviateClass.builder().className(className).build()).run().get(); - - async.roles().deleter().withName(roleName).run().get(); - Result createRole = async.roles().creator().withName(roleName) - .withPermissions(Permission.cluster(ClusterPermission.Action.READ)).run().get(); - Assertions.assertThat(createRole.getError()).as("create role").isNull(); - - async.users().db().deleter().withUserId(userName).run().get(); - Result createUser = async.users().db().creator().withUserId(userName).run().get(); - Assertions.assertThat(createUser.getError()).as("create user").isNull(); - - return null; // satisfy Callable - }), - runnable(() -> { - async.schema().classDeleter().withClassName(className).run().get(); - async.roles().deleter().withName(roleName).run().get(); - async.users().db().deleter().withUserId(userName).run().get(); - - return null; // satisfy Callable - }), - // Create backup - supplier(() -> async.backup().creator() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withIncludeClassNames("RolesUsers") - .withWaitForCompletion(true) - .run().get()), - // Restore from backup - supplier(() -> async.backup().restorer() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withIncludeClassNames("RolesUsers") - .withWaitForCompletion(true) - .withConfig(BackupRestoreConfig.builder() - .usersRestore(RbacRestoreOption.ALL) - .rolesRestore(RbacRestoreOption.ALL) - .build()) - .run().get()), - supplier(() -> async.users().db().getUser().withUserId(userName).run().get()), - supplier(() -> async.roles().getter().withName(roleName).run().get())); - } - } - - @Test - public void testOverwriteAlias_true() throws InterruptedException, ExecutionException, Exception { - String originalClass = "CollectionOverwriteAlias"; - String alias = originalClass + "Alias"; - String differentClass = "Different" + originalClass; - - try (final WeaviateAsyncClient async = client.async()) { - Runnable arrange = runnable(() -> { - Result res; - - res = async.schema().classCreator() - .withClass(WeaviateClass.builder().className(originalClass).build()) - .run().get(); - Assertions.assertThat(res.getError()).isNull(); - res = async.alias().creator().withClassName(originalClass).withAlias(alias).run().get(); - Assertions.assertThat(res.getError()).isNull(); - - res = async.backup().creator() - .withBackupId(backupId) - .withBackend(BackupTestSuite.BACKEND) - .withIncludeClassNames(originalClass) - .withWaitForCompletion(true) - .run().get(); - Assertions.assertThat(res.getError()).isNull(); - - res = async.schema().classDeleter().withClassName(originalClass).run().get(); - Assertions.assertThat(res.getError()).isNull(); - res = async.schema().classCreator() - .withClass(WeaviateClass.builder().className(differentClass).build()) - .run().get(); - Assertions.assertThat(res.getError()).isNull(); - res = async.alias().updater().withAlias(alias).withNewClassName(differentClass).run().get(); - Assertions.assertThat(res.getError()).isNull(); - - return null; // satisfy Callable - }); - - Callable> act = () -> async.backup().restorer() - .withBackupId(backupId) - .withBackend(BackupTestSuite.BACKEND) - .withIncludeClassNames(originalClass) - .withWaitForCompletion(true) - .withOverwriteAlias(true) - .run().get(); - - Supplier getAlias = supplier(() -> async.alias().getter().withAlias(alias).run().get().getResult()); - - BackupTestSuite.testOverwriteAlias_true(arrange, act, getAlias, originalClass); - } - } - - @FunctionalInterface - interface ThrowingSupplier { - T get() throws Exception; - } - - /** Convert throwing Callable into a Runnable which does not throw. */ - private static Runnable runnable(Callable c) { - return () -> { - try { - c.call(); - } catch (Exception e) { - throw new RuntimeException(e); - } - }; - } - - /** Convert throwing Supplier into one that does not throw. */ - private static Supplier supplier(ThrowingSupplier s) { - return () -> { - try { - return s.get(); - } catch (Exception e) { - throw new RuntimeException(e); - } - }; - } - - @NotNull - private Supplier> createSupplierDeletePizza() { - return () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - } - - @NotNull - private Function> createSupplierGQLOfClass() { - return (String className) -> client.graphQL().get() - .withClassName(className) - .withFields(Field.builder().name("name").build()) - .run(); - } - - private Supplier> createSupplierCreate(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupCreator creator = asyncClient.backup().creator(); - configure.accept(creator); - return creator.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Supplier> createSupplierGet(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupGetter getter = asyncClient.backup().getter(); - configure.accept(getter); - return getter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Supplier> createSupplierCreateStatus(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupCreateStatusGetter getter = asyncClient.backup().createStatusGetter(); - configure.accept(getter); - return getter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Supplier> createSupplierRestore(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupRestorer restorer = asyncClient.backup().restorer(); - configure.accept(restorer); - return restorer.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Supplier> createSupplierRestoreStatus(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupRestoreStatusGetter getter = asyncClient.backup().restoreStatusGetter(); - configure.accept(getter); - return getter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Supplier> createSupplierCanceler(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - BackupCanceler canceler = asyncClient.backup().canceler(); - configure.accept(canceler); - return canceler.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateMockServerTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateMockServerTest.java deleted file mode 100644 index 33a40f61c..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateMockServerTest.java +++ /dev/null @@ -1,324 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import org.junit.After; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.Delay; -import org.mockserver.verify.VerificationTimes; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.integration.tests.batch.BatchObjectsMockServerTestSuite; - -@Ignore // Blocking 5.1.0-alpha1 release, will be revisited before 5.1.0. -@RunWith(JParamsTestRunner.class) -public class ClientBatchCreateMockServerTest { - - private WeaviateClient client; - private ClientAndServer mockServer; - private MockServerClient mockServerClient; - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8999; - - @Before - public void before() { - mockServer = startClientAndServer(MOCK_SERVER_PORT); - mockServerClient = new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT); - - mockServerClient.when( - request().withMethod("GET").withPath("/v1/meta")).respond( - response().withStatusCode(200).withBody(metaBody())); - - Config config = new Config("http", MOCK_SERVER_HOST + ":" + MOCK_SERVER_PORT, null, 1, 1, 1); - client = new WeaviateClient(config); - } - - @After - public void stopMockServer() { - mockServer.stop(); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long expectedExecMinMillis, long expectedExecMaxMillis) { - // stop server to simulate connection issues - mockServer.stop(); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierObjectsBatcher = () -> { - try { - return asyncClient.batch().objectsBatcher(batchRetriesConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchObjectsMockServerTestSuite.testNotCreateBatchDueToConnectionIssue(supplierObjectsBatcher, - expectedExecMinMillis, expectedExecMaxMillis); - } - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateAutoBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long expectedExecMinMillis, long expectedExecMaxMillis) { - // stop server to simulate connection issues - mockServer.stop(); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Consumer>> supplierObjectsBatcher = callback -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchObjectsMockServerTestSuite.testNotCreateAutoBatchDueToConnectionIssue(supplierObjectsBatcher, - expectedExecMinMillis, expectedExecMaxMillis); - } - } - - public static Object[][] provideForNotCreateBatchDueToConnectionIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(0) - .build(), - 0, 350 - }, - new Object[] { - // final response should be available after 1 retry (400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(1) - .build(), - 400, 750 - }, - new Object[] { - // final response should be available after 2 retries (400 + 800 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(2) - .build(), - 1200, 1550 - }, - new Object[] { - // final response should be available after 1 retry (400 + 800 + 1200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(3) - .build(), - 2400, 2750 - }, - }; - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCallsCount) { - // given client times out after 1s - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.PIZZA_1); - String soup1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.SOUP_1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 - // should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - mockServerClient.when( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID))) - .respond( - response().withBody(pizza1Str)); - mockServerClient.when( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID))) - .respond( - response().withBody(soup1Str)); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierObjectsBatcher = () -> { - try { - return asyncClient.batch().objectsBatcher(batchRetriesConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - Consumer assertPostObjectsCallsCount = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(count)); - Consumer assertGetPizza1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetPizza2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_2_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetSoup1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetSoup2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_2_ID)), - VerificationTimes.exactly(count)); - - BatchObjectsMockServerTestSuite.testNotCreateBatchDueToTimeoutIssue(supplierObjectsBatcher, - assertPostObjectsCallsCount, assertGetPizza1CallsCount, assertGetPizza2CallsCount, - assertGetSoup1CallsCount, assertGetSoup2CallsCount, expectedBatchCallsCount, "1 SECONDS"); - } - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateAutoBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCallsCount) { - // given client times out after 1s - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.PIZZA_1); - String soup1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.SOUP_1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 - // should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - mockServerClient.when( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID))) - .respond( - response().withBody(pizza1Str)); - mockServerClient.when( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID))) - .respond( - response().withBody(soup1Str)); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Consumer>> supplierObjectsBatcher = callback -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Consumer assertPostObjectsCallsCount = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(count)); - Consumer assertGetPizza1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetPizza2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_2_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetSoup1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)), - VerificationTimes.exactly(count)); - Consumer assertGetSoup2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET") - .withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_2_ID)), - VerificationTimes.exactly(count)); - - BatchObjectsMockServerTestSuite.testNotCreateAutoBatchDueToTimeoutIssue(supplierObjectsBatcher, - assertPostObjectsCallsCount, assertGetPizza1CallsCount, assertGetPizza2CallsCount, - assertGetSoup1CallsCount, assertGetSoup2CallsCount, expectedBatchCallsCount, "1 SECONDS"); - } - } - - public static Object[][] provideForNotCreateBatchDueToTimeoutIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(0) - .build(), - 1 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(1) - .build(), - 2 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(2) - .build(), - 3 - }, - }; - } - - private String metaBody() { - return String.format("{\n" + - " \"hostname\": \"http://[::]:%s\",\n" + - " \"modules\": {},\n" + - " \"version\": \"%s\"\n" + - "}", MOCK_SERVER_PORT, "1.17.999-mock-server-version"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateTest.java deleted file mode 100644 index f37189cff..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchCreateTest.java +++ /dev/null @@ -1,215 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchObjectsTestSuite; -import org.jetbrains.annotations.NotNull; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -public class ClientBatchCreateTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - testGenerics.createWeaviateTestSchemaFood(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateBatch() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Function> supplierObjectsBatcherPizzas = pizza -> { - try { - return asyncClient.batch().objectsBatcher() - .withObjects(pizza, WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build()) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - Function> supplierObjectsBatcherSoups = soup -> { - try { - return asyncClient.batch().objectsBatcher() - .withObjects(soup, WeaviateObject.builder() - .className("Soup") - .id(BatchObjectsTestSuite.SOUP_2_ID) - .properties(BatchObjectsTestSuite.SOUP_2_PROPS) - .build()) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchObjectsTestSuite.testCreateBatch(supplierObjectsBatcherPizzas, supplierObjectsBatcherSoups, - createSupplierDataPizza1(), createSupplierDataSoup1(), - createSupplierGetterPizza1(), createSupplierGetterPizza2(), - createSupplierGetterSoup1(), createSupplierGetterSoup2()); - } - } - - @Test - public void shouldCreateAutoBatch() { - try (WeaviateAsyncClient asyncClient = client.async()) { - BiConsumer>> supplierObjectsBatcherPizzas = (pizza, callback) -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().objectsAutoBatcher(autoBatchConfig) - .withObjects(pizza, WeaviateObject.builder().className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build()) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - BiConsumer>> supplierObjectsBatcherSoups = (soup, callback) -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().objectsAutoBatcher(autoBatchConfig) - .withObjects(soup, WeaviateObject.builder() - .className("Soup") - .id(BatchObjectsTestSuite.SOUP_2_ID) - .properties(BatchObjectsTestSuite.SOUP_2_PROPS) - .build()) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchObjectsTestSuite.testCreateAutoBatch(supplierObjectsBatcherPizzas, supplierObjectsBatcherSoups, - createSupplierDataPizza1(), createSupplierDataSoup1(), - createSupplierGetterPizza1(), createSupplierGetterPizza2(), - createSupplierGetterSoup1(), createSupplierGetterSoup2()); - } - } - - @Test - public void shouldCreateBatchWithPartialError() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierObjectsBatcherPizzas = () -> { - WeaviateObject pizzaWithError = WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_1_ID) - .properties(BatchObjectsTestSuite.createFoodProperties(1, "This pizza should throw a invalid name error")) - .build(); - WeaviateObject pizza = WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build(); - - try { - return asyncClient.batch().objectsBatcher() - .withObjects(pizzaWithError, pizza) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchObjectsTestSuite.testCreateBatchWithPartialError(supplierObjectsBatcherPizzas, - createSupplierGetterPizza1(), createSupplierGetterPizza2()); - } - } - - @NotNull - private Supplier> createSupplierDataSoup1() { - return () -> client.data().creator() - .withClassName("Soup") - .withID(BatchObjectsTestSuite.SOUP_1_ID) - .withProperties(BatchObjectsTestSuite.SOUP_1_PROPS) - .run(); - } - - @NotNull - private Supplier> createSupplierDataPizza1() { - return () -> client.data().creator() - .withClassName("Pizza") - .withID(BatchObjectsTestSuite.PIZZA_1_ID) - .withProperties(BatchObjectsTestSuite.PIZZA_1_PROPS) - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterPizza1() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.PIZZA_1_ID) - .withClassName("Pizza") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterPizza2() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.PIZZA_2_ID) - .withClassName("Pizza") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterSoup1() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.SOUP_1_ID) - .withClassName("Soup") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterSoup2() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.SOUP_2_ID) - .withClassName("Soup") - .run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchDeleteTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchDeleteTest.java deleted file mode 100644 index db7a6998f..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchDeleteTest.java +++ /dev/null @@ -1,121 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.batch.model.BatchDeleteOutput; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.ClientBatchDeleteTestSuite; -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; -import java.util.function.Supplier; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientBatchDeleteTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics.createTestSchemaAndData(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - Supplier>> getObjects = () -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.data().objectsGetter().run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - @Test - public void testBatchDeleteDryRunVerbose() { - Function> batchDelete = (whereFilter) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatchDeleter() - .withDryRun(true) - .withOutput(BatchDeleteOutput.VERBOSE) - .withClassName("Pizza") - .withWhere(whereFilter) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - ClientBatchDeleteTestSuite.testBatchDeleteDryRunVerbose(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteDryRunMinimal() { - Function> batchDelete = (whereFilter) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatchDeleter() - .withDryRun(true) - .withOutput(BatchDeleteOutput.MINIMAL) - .withClassName("Soup") - .withWhere(whereFilter) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - ClientBatchDeleteTestSuite.testBatchDeleteDryRunMinimal(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteNoMatchWithDefaultOutputAndDryRun() { - Function> batchDelete = (whereFilter) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatchDeleter() - .withClassName("Pizza") - .withWhere(whereFilter) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - ClientBatchDeleteTestSuite.testBatchDeleteNoMatchWithDefaultOutputAndDryRun(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteAllMatchesWithDefaultDryRun() { - Function> batchDelete = (whereFilter) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatchDeleter() - .withOutput(BatchDeleteOutput.VERBOSE) - .withClassName("Pizza") - .withWhere(whereFilter) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - ClientBatchDeleteTestSuite.testBatchDeleteAllMatchesWithDefaultDryRun(getObjects, batchDelete); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateNamedVectorsTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateNamedVectorsTest.java deleted file mode 100644 index d327d52e3..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateNamedVectorsTest.java +++ /dev/null @@ -1,136 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; - -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.batch.ClientBatchGrpcCreateNamedVectorsTestSuite; - -public class ClientBatchGrpcCreateNamedVectorsTest { - private static String httpHost; - private static String grpcHost; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - httpHost = compose.getHttpHostAddress(); - grpcHost = compose.getGrpcHostAddress(); - } - - @Test - public void shouldCreateObjectsWithNamedVectors() { - WeaviateClient client = createClient(); - - Function> classCreate = (weaviateClass) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classCreator() - .withClass(weaviateClass) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> batchCreate = (weaviateObj) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatcher() - .withObjects(weaviateObj) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function>> fetch = (weaviateObject) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.data().objectsGetter() - .withID(weaviateObject.getId()) - .withClassName(weaviateObject.getClassName()) - .withVector() - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> deleteClass = (className) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classDeleter().withClassName(className).run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - ClientBatchGrpcCreateNamedVectorsTestSuite.shouldCreateObjectsWithNamedVectors(classCreate, batchCreate, fetch, - deleteClass); - } - - @Test - public void shouldCreateObjectsWithNamedMultiVectors() { - WeaviateClient client = createClient(); - - Function> classCreate = (weaviateClass) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classCreator() - .withClass(weaviateClass) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> batchCreate = (weaviateObj) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatcher() - .withObjects(weaviateObj) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function>> fetch = (weaviateObject) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.data().objectsGetter() - .withID(weaviateObject.getId()) - .withClassName(weaviateObject.getClassName()) - .withVector() - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> deleteClass = (className) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classDeleter().withClassName(className).run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - ClientBatchGrpcCreateNamedVectorsTestSuite.shouldCreateObjectsWithNamedMultiVectors(classCreate, batchCreate, fetch, - deleteClass); - } - - private WeaviateClient createClient() { - Config config = new Config("http", httpHost); - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - return new WeaviateClient(config); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateTest.java deleted file mode 100644 index 0d7a265ee..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchGrpcCreateTest.java +++ /dev/null @@ -1,142 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import java.util.List; -import java.util.UUID; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; - -import org.assertj.core.api.Assertions; -import org.assertj.core.api.InstanceOfAssertFactories; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchObjectsTestSuite; -import io.weaviate.integration.tests.batch.ClientBatchGrpcCreateTestSuite; - -public class ClientBatchGrpcCreateTest { - - private static String httpHost; - private static String grpcHost; - - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - httpHost = compose.getHttpHostAddress(); - grpcHost = compose.getGrpcHostAddress(); - - WeaviateClient client = createClient(false); - - testGenerics.cleanupWeaviate(client); - testGenerics.createWeaviateTestSchemaFood(client); - } - - @Test - public void shouldCreateGRPC() { - shouldCreate(true); - } - - @Test - public void shouldCreateWithoutGRPC() { - shouldCreate(false); - } - - public void shouldCreate(boolean useGRPC) { - WeaviateClient client = createClient(useGRPC); - - Function> createClass = (weaviateClass) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classCreator() - .withClass(weaviateClass) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> batchCreate = (objects) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.batch().objectsBatcher() - .withObjects(objects) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function>> fetchObject = (obj) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.data().objectsGetter() - .withID(obj.getId()).withClassName(obj.getClassName()).withVector() - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - Function> deleteClass = (className) -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.schema().classDeleter().withClassName(className).run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - ClientBatchGrpcCreateTestSuite.shouldCreateBatch(client, createClass, batchCreate, fetchObject, deleteClass); - } - - @Test - public void testPartialErrorResponse() throws ExecutionException, InterruptedException { - WeaviateClient syncClient = createClient(true); - - try (WeaviateAsyncClient client = syncClient.async()) { - - WeaviateObject[] batchObjects = { - WeaviateObject.builder() - .className("Pizza") - .id(UUID.randomUUID().toString()) - .properties(BatchObjectsTestSuite.createFoodProperties(1, "This pizza should throw a invalid name error")) - .build(), - WeaviateObject.builder() - .className("Pizza") - .id(UUID.randomUUID().toString()) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build(), - }; - - Result result = client.batch().objectsBatcher() - .withObjects(batchObjects) - .run().get(); - - Assertions.assertThat(result).as("batch insert result") - .returns(true, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(InstanceOfAssertFactories.array(ObjectGetResponse[].class)) - .hasSameSizeAs(batchObjects).as("all batch objects included in the response"); - - Assertions.assertThat(result.getResult()[0].getResult().getErrors().getError().get(0).getMessage()) - .contains("invalid text property 'name' on class 'Pizza': not a string, but float64"); - } - } - - private WeaviateClient createClient(Boolean useGRPC) { - Config config = new Config("http", httpHost); - if (useGRPC) { - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - } - return new WeaviateClient(config); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateMockServerTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateMockServerTest.java deleted file mode 100644 index ae3d25ca6..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateMockServerTest.java +++ /dev/null @@ -1,273 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import org.junit.After; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.Delay; -import org.mockserver.verify.VerificationTimes; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.integration.tests.batch.BatchReferencesMockServerTestSuite; - -@Ignore // Blocking 5.1.0-alpha1 release, will be revisited before 5.1.0. -@RunWith(JParamsTestRunner.class) -public class ClientBatchReferencesCreateMockServerTest { - - private WeaviateClient client; - private ClientAndServer mockServer; - private MockServerClient mockServerClient; - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8999; - - private static final BatchReference refPizzaToSoup = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_PIZZA) - .to(BatchReferencesMockServerTestSuite.TO_SOUP) - .build(); - private static final BatchReference refSoupToPizza = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_SOUP) - .to(BatchReferencesMockServerTestSuite.TO_PIZZA) - .build(); - private static final BatchReference refPizzaToPizza = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_PIZZA) - .to(BatchReferencesMockServerTestSuite.TO_PIZZA) - .build(); - private static final BatchReference refSoupToSoup = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_SOUP) - .to(BatchReferencesMockServerTestSuite.TO_SOUP) - .build(); - - @Before - public void before() { - mockServer = startClientAndServer(MOCK_SERVER_PORT); - mockServerClient = new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT); - - mockServerClient.when( - request().withMethod("GET").withPath("/v1/meta")).respond( - response().withStatusCode(200).withBody(metaBody())); - - Config config = new Config("http", MOCK_SERVER_HOST + ":" + MOCK_SERVER_PORT, null, 1, 1, 1); - client = new WeaviateClient(config); - } - - @After - public void stopMockServer() { - mockServer.stop(); - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToConnectionIssue") - public void shouldNotCreateBatchReferencesDueToConnectionIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - long execMin, long execMax) { - // stop server to simulate connection issues - mockServer.stop(); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierReferencesBatcher = () -> { - try { - return asyncClient.batch().referencesBatcher(batchRetriesConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchReferencesMockServerTestSuite.testNotCreateBatchReferencesDueToConnectionIssue(supplierReferencesBatcher, - execMin, execMax); - } - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToConnectionIssue") - public void shouldNotCreateAutoBatchReferencesDueToConnectionIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - long execMin, long execMax) { - // stop server to simulate connection issues - mockServer.stop(); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Consumer>> supplierReferencesBatcher = callback -> { - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().referencesAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchReferencesMockServerTestSuite.testNotCreateAutoBatchReferencesDueToConnectionIssue(supplierReferencesBatcher, - execMin, execMax); - } - } - - public static Object[][] provideForNotCreateBatchReferencesDueToConnectionIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(0) - .build(), - 0, 100 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(1) - .build(), - 200, 300 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(2) - .build(), - 600, 700 - }, - new Object[] { - // final response should be available after 1 retry (200 + 400 + 600 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(3) - .build(), - 1200, 1300 - }, - }; - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToTimeoutIssue") - public void shouldNotCreateBatchReferencesDueToTimeoutIssue(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/references")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierReferencesBatcher = () -> { - try { - return asyncClient.batch().referencesBatcher(batchRetriesConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - Consumer assertBatchCallsTimes = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/references"), - VerificationTimes.exactly(count)); - - BatchReferencesMockServerTestSuite.testNotCreateBatchReferencesDueToTimeoutIssue(supplierReferencesBatcher, - assertBatchCallsTimes, expectedBatchCalls, "1 SECONDS"); - } - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToTimeoutIssue") - public void shouldNotCreateAutoBatchReferencesDueToTimeoutIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/references")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Consumer>> supplierReferencesBatcher = callback -> { - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().referencesAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - Consumer assertBatchCallsTimes = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/references"), - VerificationTimes.exactly(count)); - - BatchReferencesMockServerTestSuite.testNotCreateAutoBatchReferencesDueToTimeoutIssue(supplierReferencesBatcher, - assertBatchCallsTimes, expectedBatchCalls, "1 SECONDS"); - } - } - - public static Object[][] provideForNotCreateBatchReferencesDueToTimeoutIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(0) - .build(), - 1 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(1) - .build(), - 2 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(2) - .build(), - 3 - }, - }; - } - - private String metaBody() { - return String.format("{\n" + - " \"hostname\": \"http://[::]:%s\",\n" + - " \"modules\": {},\n" + - " \"version\": \"%s\"\n" + - "}", MOCK_SERVER_PORT, "1.17.999-mock-server-version"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateTest.java b/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateTest.java deleted file mode 100644 index e91438038..000000000 --- a/src/test/java/io/weaviate/integration/client/async/batch/ClientBatchReferencesCreateTest.java +++ /dev/null @@ -1,172 +0,0 @@ -package io.weaviate.integration.client.async.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchReferencesTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Supplier; - -public class ClientBatchReferencesCreateTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateBatchReferences() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierReferencesBatcherResult = () -> { - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", BatchReferencesTestSuite.SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", BatchReferencesTestSuite.SOUP_ID); - BatchReference refPizzaToSoup = BatchReference.builder().from(fromPizza).to(toSoup).build(); - BatchReference refSoupToPizza = BatchReference.builder().from(fromSoup).to(toPizza).build(); - BatchReference refPizzaToPizza = BatchReference.builder().from(fromPizza).to(toPizza).build(); - BatchReference refSoupToSoup = BatchReference.builder().from(fromSoup).to(toSoup).build(); - - try { - return asyncClient.batch().referencesBatcher() - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchReferencesTestSuite.testCreateBatchReferences(supplierReferencesBatcherResult, - supplierObjectsBatcher(), supplierGetterPizzaResult(), supplierGetterSoupResult()); - } - } - - @Test - public void shouldCreateAutoBatchReferences() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Consumer>> supplierReferencesBatcherResult = (Consumer> callback) -> { - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", BatchReferencesTestSuite.SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", BatchReferencesTestSuite.SOUP_ID); - BatchReference refPizzaToSoup = BatchReference.builder().from(fromPizza).to(toSoup).build(); - BatchReference refSoupToPizza = BatchReference.builder().from(fromSoup).to(toPizza).build(); - BatchReference refPizzaToPizza = BatchReference.builder().from(fromPizza).to(toPizza).build(); - BatchReference refSoupToSoup = BatchReference.builder().from(fromSoup).to(toSoup).build(); - - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - try { - asyncClient.batch().referencesAutoBatcher(autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchReferencesTestSuite.testCreateAutoBatchReferences(supplierReferencesBatcherResult, - supplierObjectsBatcher(), supplierGetterPizzaResult(), supplierGetterSoupResult()); - } - } - - @Test - public void shouldCreateAutoBatchReferencesWithReturn() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> supplierReferencesBatcherResult = () -> { - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", BatchReferencesTestSuite.SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", BatchReferencesTestSuite.SOUP_ID); - BatchReference refPizzaToSoup = BatchReference.builder().from(fromPizza).to(toSoup).build(); - BatchReference refSoupToPizza = BatchReference.builder().from(fromSoup).to(toPizza).build(); - BatchReference refPizzaToPizza = BatchReference.builder().from(fromPizza).to(toPizza).build(); - BatchReference refSoupToSoup = BatchReference.builder().from(fromSoup).to(toSoup).build(); - - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .build(); - - try { - return asyncClient.batch().referencesAutoBatcher(autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run() - .get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - - BatchReferencesTestSuite.testCreateBatchReferences(supplierReferencesBatcherResult, - supplierObjectsBatcher(), supplierGetterPizzaResult(), supplierGetterSoupResult()); - } - } - - private Supplier> supplierObjectsBatcher() { - return () -> client.batch().objectsBatcher() - .withObjects(new WeaviateObject[]{ - WeaviateObject.builder() - .id(BatchReferencesTestSuite.PIZZA_ID) - .className("Pizza") - .properties(BatchReferencesTestSuite.PIZZA_PROPS) - .build(), - WeaviateObject.builder() - .id(BatchReferencesTestSuite.SOUP_ID) - .className("Soup") - .properties(BatchReferencesTestSuite.SOUP_PROPS) - .build() - }) - .run(); - } - - private Supplier>> supplierGetterPizzaResult() { - return () -> client.data().objectsGetter() - .withID(BatchReferencesTestSuite.PIZZA_ID) - .withClassName("Pizza") - .run(); - } - - private Supplier>> supplierGetterSoupResult() { - return () -> client.data().objectsGetter() - .withID(BatchReferencesTestSuite.SOUP_ID) - .withClassName("Soup") - .run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/classifications/ClientClassificationsTest.java b/src/test/java/io/weaviate/integration/client/async/classifications/ClientClassificationsTest.java deleted file mode 100644 index 6d4dbd061..000000000 --- a/src/test/java/io/weaviate/integration/client/async/classifications/ClientClassificationsTest.java +++ /dev/null @@ -1,114 +0,0 @@ -package io.weaviate.integration.client.async.classifications; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.classifications.api.Scheduler; -import io.weaviate.client.v1.classifications.model.Classification; -import io.weaviate.client.v1.classifications.model.ClassificationType; -import io.weaviate.client.v1.classifications.model.ParamsKNN; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.classifications.ClassificationsTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -public class ClientClassificationsTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testClassificationScheduler() { - String[] classifyProperties = new String[]{"tagged"}; - String[] basedOnProperties = new String[]{"description"}; - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplier = createSupplierScheduler( - asyncClient, scheduler -> scheduler - .withType(ClassificationType.Contextual) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - ); - Supplier> resultSupplierComplete = createSupplierScheduler( - asyncClient, scheduler -> scheduler - .withType(ClassificationType.Contextual) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - .withWaitForCompletion() - ); - - ClassificationsTestSuite.testScheduler(resultSupplier, resultSupplierComplete, testGenerics, client); - } - } - - @Test - public void testClassificationGetter() { - String[] classifyProperties = new String[]{"tagged"}; - String[] basedOnProperties = new String[]{"description"}; - ParamsKNN paramsKNN = ParamsKNN.builder().k(3).build(); - - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplierScheduler = createSupplierScheduler( - asyncClient, scheduler -> scheduler - .withType(ClassificationType.KNN) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - .withSettings(paramsKNN) - ); - Function> resultSupplierGetter = createSupplierGetter(asyncClient); - - ClassificationsTestSuite.testGetter(resultSupplierScheduler, resultSupplierGetter, testGenerics, client); - } - } - - private Supplier> createSupplierScheduler(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - Scheduler scheduler = asyncClient.classifications().scheduler(); - configure.accept(scheduler); - return scheduler.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } - - private Function> createSupplierGetter(WeaviateAsyncClient asyncClient) { - return (String id) -> { - try { - return asyncClient.classifications().getter() - .withID(id) - .run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterMultiTenancyTest.java deleted file mode 100644 index a877ffc20..000000000 --- a/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterMultiTenancyTest.java +++ /dev/null @@ -1,77 +0,0 @@ -package io.weaviate.integration.client.async.cluster; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.cluster.api.NodesStatusGetter; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.cluster.ClusterMultiTenancyTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Supplier; - -public class ClientClusterMultiTenancyTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - - @Test - public void shouldGetNodeStatusPerClass() throws InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplierAll = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - ); - Supplier> resultSupplierPizza = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Pizza") - ); - Supplier> resultSupplierSoup = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Soup") - ); - - ClusterMultiTenancyTestSuite.testMultiTenancyDataPerClassOutputVerbose(resultSupplierAll, resultSupplierPizza, resultSupplierSoup, - testGenerics, client); - } - } - - private Supplier> createSupplier(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - NodesStatusGetter nodesStatusGetter = asyncClient.cluster().nodesStatusGetter(); - configure.accept(nodesStatusGetter); - return nodesStatusGetter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterTest.java b/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterTest.java deleted file mode 100644 index 41937e9b8..000000000 --- a/src/test/java/io/weaviate/integration/client/async/cluster/ClientClusterTest.java +++ /dev/null @@ -1,111 +0,0 @@ -package io.weaviate.integration.client.async.cluster; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.cluster.api.NodesStatusGetter; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.cluster.ClusterTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; -import java.util.function.Supplier; - -public class ClientClusterTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testClusterNodesEndpointWithoutDataWithOutputVerbose() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplier = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - ); - - ClusterTestSuite.testNoDataOutputVerbose(resultSupplier); - } - } - - @Test - public void testClusterNodesEndpointWithDataWithOutputVerbose() throws InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplier = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - ); - - ClusterTestSuite.testDataOutputVerbose(resultSupplier, testGenerics, client); - } - } - - @Test - public void shouldGetNodeStatusPerClassWithOutputVerbose() throws InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplierAll = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - ); - Supplier> resultSupplierPizza = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Pizza") - ); - Supplier> resultSupplierSoup = createSupplier( - asyncClient, nodesStatusGetter -> nodesStatusGetter - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Soup") - ); - - ClusterTestSuite.testDataPerClassOutputVerbose(resultSupplierAll, resultSupplierPizza, resultSupplierSoup, - testGenerics, client); - } - } - - @Test - public void testClusterNodesEndpointWithOutputMinimalImplicit() { - try (WeaviateAsyncClient asyncClient = client.async()) { - Supplier> resultSupplier = createSupplier( - asyncClient, nodesStatusGetter -> {} - ); - - ClusterTestSuite.testNoDataOutputMinimalImplicit(resultSupplier); - } - } - - private Supplier> createSupplier(WeaviateAsyncClient asyncClient, - Consumer configure) { - return () -> { - try { - NodesStatusGetter nodesStatusGetter = asyncClient.cluster().nodesStatusGetter(); - configure.accept(nodesStatusGetter); - return nodesStatusGetter.run().get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/cluster/ClientReplicateTest.java b/src/test/java/io/weaviate/integration/client/async/cluster/ClientReplicateTest.java deleted file mode 100644 index 39a8abf04..000000000 --- a/src/test/java/io/weaviate/integration/client/async/cluster/ClientReplicateTest.java +++ /dev/null @@ -1,223 +0,0 @@ -package io.weaviate.integration.client.async.cluster; - -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.List; -import java.util.concurrent.Callable; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -import org.assertj.core.api.Assertions; -import org.assertj.core.util.Arrays; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.cluster.api.replication.Replication; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperationState; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.client.v1.cluster.model.ReplicationType; -import io.weaviate.client.v1.cluster.model.ShardReplicas; -import io.weaviate.client.v1.cluster.model.ShardingState; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerComposeCluster; - -public class ClientReplicateTest { - @ClassRule - public static WeaviateDockerComposeCluster cluster = new WeaviateDockerComposeCluster(); - - private static WeaviateAsyncClient client; - - @Before - public void before() { - Config config = new Config("http", cluster.getHttpHost0Address()); - client = new WeaviateClient(config).async(); - } - - private static final String CLASSNAME = "ShardDweller"; - - @After - public void afterEach() { - client.schema().classDeleter().withClassName(CLASSNAME).run(); - } - - @AfterClass - public static void afterAll() { - client.close(); - } - - @Test - public void testQueryShardingState() throws InterruptedException, ExecutionException { - // Arrange - Boolean created = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(CLASSNAME).build()) - .run().get().getResult(); - assumeTrue(created, "created test collection"); - - NodesStatusResponse nodes = client.cluster().nodesStatusGetter() - .withClassName(CLASSNAME) - .withOutput(NodeStatusOutput.VERBOSE) - .run().get().getResult(); - - assumeTrue(nodes != null, "nodes status result is not null"); - assumeTrue(!Arrays.isArrayEmpty(nodes.getNodes()), "there're 1+ nodes in the cluster"); - String wantShard = nodes.getNodes()[0].getShards()[0].getName(); - - ShardingState shardingState; - - // Act: query by collection name - shardingState = client.cluster().shardingStateQuerier() - .withClassName(CLASSNAME) - .run().get().getResult(); - Assertions.assertThat(shardingState.getShards()) - .as("shard present in the sharding state output (by collection)") - .extracting(ShardReplicas::getName).contains(wantShard); - - // Act: query by collection + shard name - shardingState = client.cluster().shardingStateQuerier() - .withClassName(CLASSNAME) - .withShard(wantShard) - .run().get().getResult(); - Assertions.assertThat(shardingState.getShards()) - .as("shard present in the sharding state output (by collection+shard)") - .extracting(ShardReplicas::getName).contains(wantShard); - - ShardingState inexistent; - // Act: query inexistent - inexistent = client.cluster().shardingStateQuerier() - .withClassName("Unknown") - .run().get().getResult(); - Assertions.assertThat(inexistent).isNull(); - } - - @Test - /** - * This test starts a replication operation between two nodes, - * queries for its status, then cancels the replication and eventually deletes - * it. - * - * Note that assertions that use {@link #eventually} helper may be flaky. - */ - public void testReplicateLifecycle() throws InterruptedException, ExecutionException { - // Arrange - Boolean created = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(CLASSNAME).build()) - .run().get().getResult(); - assumeTrue(created, "created test collection"); - - NodesStatusResponse nodes = client.cluster().nodesStatusGetter() - .withClassName(CLASSNAME) - .withOutput(NodeStatusOutput.VERBOSE) - .run().get().getResult(); - - assumeTrue(nodes != null, "nodes status result is not null"); - assumeTrue(nodes.getNodes().length >= 2, "there're 2+ nodes in the cluster"); - - String srcNode = nodes.getNodes()[0].getName(); - String tgtNode = nodes.getNodes()[1].getName(); - String wantShard = nodes.getNodes()[0].getShards()[0].getName(); - - deleteAllReplications(5); - - // Act: kick-off replication - String uuid = client.cluster().replicator() - .withClassName(CLASSNAME) - .withShard(wantShard) - .withSourceNode(srcNode) - .withTargetNode(tgtNode) - .run().get().getResult(); - assumeTrue(uuid != null, "replication started with valid uuid"); - - // Act: get status - ReplicateOperation status_1 = client.cluster().replication().getter() - .withUuid(uuid).run().get().getResult(); - - Assertions.assertThat(status_1).isNotNull() - .as("expected replication status") - .returns(CLASSNAME, ReplicateOperation::getClassName) - .returns(wantShard, ReplicateOperation::getShard) - .returns(srcNode, ReplicateOperation::getSourceNode) - .returns(tgtNode, ReplicateOperation::getTargetNode) - .returns(ReplicationType.COPY, ReplicateOperation::getTransferType) - .returns(null, ReplicateOperation::getStatusHistory) - .extracting(ReplicateOperation::getStatus).isNotNull(); - - // Act: get status with history - ReplicateOperation status_2 = client.cluster().replication().getter() - .withUuid(uuid).withIncludeHistory(true) - .run().get().getResult(); - - Assertions.assertThat(status_2).isNotNull() - .as("includes replication status history") - .extracting(ReplicateOperation::getStatusHistory).isNotNull(); - - // Act: query status - List operations = client.cluster().replication().querier() - .withClassName(CLASSNAME).withShard(wantShard).withTargetNode(tgtNode) - .run().get().getResult(); - - Assertions.assertThat(operations).as("no. replications").hasSize(1); - - // Act: cancel - Result cancel = client.cluster().replication().canceler().withUuid(uuid).run().get(); - Assertions.assertThat(cancel).as("cancel error").returns(null, Result::getError); - - eventually(() -> client.cluster().replication().getter().withUuid(uuid).run().get().getResult() - .getStatus().getState() == ReplicateOperationState.CANCELLED, - 25, "replication was not cancelled"); - - // Act: delete - Result delete = client.cluster().replication().deleter().withUuid(uuid).run().get(); - Assertions.assertThat(delete).as("delete error").returns(null, Result::getError); - - eventually(() -> client.cluster().replication().allGetter().run().get().getResult().isEmpty(), - 15, "replication was not deleted"); - } - - private static void deleteAllReplications(int timeoutSeconds) { - Replication replication = client.cluster().replication(); - replication.allDeleter().run(); - eventually(() -> replication.allGetter().run().get().getResult().isEmpty(), - timeoutSeconds, - "did not delete existing replications"); - } - - private static void eventually(Callable cond, int timeoutSeconds, String... message) { - CompletableFuture check = CompletableFuture.runAsync(() -> { - try { - while (!Thread.currentThread().isInterrupted() && !cond.call()) { - try { - Thread.sleep(500); - } catch (InterruptedException ex) { - Thread.currentThread().interrupt(); - } - } - } catch (Exception e) { - // Propagate to callee - throw new RuntimeException(e); - } - }); - - try { - check.get(timeoutSeconds, TimeUnit.SECONDS); - } catch (TimeoutException ex) { - check.cancel(true); - Assertions.fail(message.length >= 0 ? message[0] : null, ex); - } catch (InterruptedException ex) { - Thread.currentThread().interrupt(); - Assertions.fail(ex); - } catch (ExecutionException ex) { - throw new RuntimeException(ex); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java b/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java deleted file mode 100644 index 3211c3853..000000000 --- a/src/test/java/io/weaviate/integration/client/async/data/ClientDataTest.java +++ /dev/null @@ -1,739 +0,0 @@ -package io.weaviate.integration.client.async.data; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.jupiter.api.Assumptions.assumeFalse; -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.ExecutionException; - -import org.assertj.core.api.Assertions; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.misc.model.MultiVectorConfig; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.MuveraConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.data.DataTestSuite; - -public class ClientDataTest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - @Test - public void testDataCreate() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataCreate.objTID; - String objAID = DataTestSuite.testDataCreate.objAID; - Map propertiesSchemaT = DataTestSuite.testDataCreate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataCreate.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).withConsistencyLevel(ConsistencyLevel.QUORUM).run() - .get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).withConsistencyLevel(ConsistencyLevel.QUORUM).run() - .get(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - Result> objectsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataCreate.assertResults(objectT, objectA, objectsT, objectsA); - } - } - - @Test - public void testDataCreateAndRetrieveMultiVectors() - throws ExecutionException, InterruptedException { - WeaviateClient syncClient = new WeaviateClient(new Config("http", address)); - try (WeaviateAsyncClient client = syncClient.async()) { - - // Arrange: Configure collection and create it - String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("regular", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexType("hnsw").build()); - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()).build()) - .vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = - client.schema().classCreator().withClass(weaviateClass).run().get(); - assumeTrue(createResult.getResult(), "schema created successfully"); - - String id = UUID.randomUUID().toString(); - Float[][] colbertVector = - new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, - {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; - - // Act: Insert test data - Result insertResult = client.data().creator().withID(id) - .withClassName(className).withProperties(new HashMap() { - { - this.put("name", "TestObject-1"); - this.put("title", "The Lord of the Rings"); - } - }).withVectors(new HashMap() { - { - this.put("regular", colbertVector[0]); - } - }).withMultiVectors(new HashMap() { - { - this.put("colbert", colbertVector); - } - }).run().get(); - - // Assert: Retrieve object and check its dimensions - Result> getResult = client.data().objectsGetter() - .withClassName(className).withID(id).withVector().run().get(); - - Assertions.assertThat(getResult).isNotNull().returns(null, Result::getError) - .as("get object error").extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object").satisfies(o -> { - Assertions.assertThat(o.getVectors()).as("1d-vectors").isNotEmpty() - .containsOnlyKeys("regular"); - - Assertions.assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() - .containsOnlyKeys("colbert").satisfies(multi -> { - Assertions.assertThat(multi.get("colbert")).as("colbert multivector") - .isEqualTo(colbertVector); - }); - }).as("expected object metadata"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(syncClient); - } - } - - @Test - public void testCreateMuvera() throws ExecutionException, InterruptedException { - WeaviateClient syncClient = new WeaviateClient(new Config("http", address)); - try (WeaviateAsyncClient client = syncClient.async()) { - - // Arrange: Configure collection and create it - String className = "NamedMuvera"; - MuveraConfig muveraConfig = - MuveraConfig.builder().enabled(true).ksim(10).dprojections(16).repetitions(20).build(); - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().encoding(muveraConfig).build()) - .bq(BQConfig.builder().enabled(true).build()).build(); - - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(vectorIndexConfig).vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = - client.schema().classCreator().withClass(weaviateClass).run().get(); - assumeTrue(createResult.getResult(), "schema created successfully"); - - Result schemaResult = client.schema().getter().run().get(); - MuveraConfig result = schemaResult.getResult().getClasses().get(0).getVectorConfig() - .get("colbert").getVectorIndexConfig().getMultiVector().getMuveraEncoding(); - assumeTrue(result.equals(muveraConfig), "muvera config is correct"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(syncClient); - } - } - - @Test - public void testDataCreateWithSpecialCharacters() - throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataCreateWithSpecialCharacters.objTID; - String name = DataTestSuite.testDataCreateWithSpecialCharacters.name; - String description = DataTestSuite.testDataCreateWithSpecialCharacters.description; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithSpecialCharacters.propertiesSchemaT(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataCreateWithSpecialCharacters.assertResults(objectT, objectsT); - } - } - - @Test - public void testDataGetActionsThings() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result pizzaObj1 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Margherita"); - put("description", "plain"); - } - }).run().get(); - Result pizzaObj2 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Pepperoni"); - put("description", "meat"); - } - }).run().get(); - Result soupObj1 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Chicken"); - put("description", "plain"); - } - }).run().get(); - Result soupObj2 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Tofu"); - put("description", "vegetarian"); - } - }).run().get(); - Result> objects = client.data().objectsGetter().run().get(); - Result> objects1 = - client.data().objectsGetter().withClassName("Pizza").withLimit(1).run().get(); - assertNull(objects1.getError()); - assertEquals(1l, objects1.getResult().size()); - String firstPizzaID = objects1.getResult().get(0).getId(); - Result> afterFirstPizzaObjects = client.data().objectsGetter() - .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1).run().get(); - - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, - objects, afterFirstPizzaObjects); - } - } - - @Test - public void testDataGetWithAdditional() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataGetWithAdditional.objTID; - String objAID = DataTestSuite.testDataGetWithAdditional.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - Result> objectsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); - Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) - .withClassName("Pizza").withAdditional("classification") - .withAdditional("nearestNeighbors").withVector().run().get(); - Result> objsAdditionalA = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withAdditional("classification").withAdditional("nearestNeighbors") - .withAdditional("interpretation").withVector().run().get(); - Result> objsAdditionalA1 = - client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - Result> objsAdditionalA2 = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withAdditional("interpretation").run().get(); - Result> objsAdditionalAError = client.data().objectsGetter() - .withID(objAID).withClassName("Soup").withAdditional("featureProjection").run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataGetWithAdditional.assertResults(objectT, objectA, objectsT, objectsA, - objsAdditionalT, objsAdditionalA, objsAdditionalA1, objsAdditionalA2, - objsAdditionalAError); - } - } - - @Test - public void testDataDelete() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataDelete.objTID; - String objAID = DataTestSuite.testDataDelete.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataDelete.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataDelete.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - Result deleteObjT = client.data().deleter().withClassName("Pizza").withID(objTID) - .withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); - Result> objTlist = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - Result deleteObjA = client.data().deleter().withClassName("Soup").withID(objAID) - .withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); - Result> objAlist = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, - objAlist); - } - } - - @Test - public void testDataUpdate() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataUpdate.objTID; - String objAID = DataTestSuite.testDataUpdate.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataUpdate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataUpdate.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - Result updateObjectT = client.data().updater().withClassName("Pizza").withID(objTID) - .withProperties(new HashMap() { - { - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - } - }).withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); - Result updateObjectA = client.data().updater().withClassName("Soup").withID(objAID) - .withProperties(new HashMap() { - { - put("name", "ChickenSoup"); - put("description", - "Used by humans when their inferior genetics are attacked by microscopic organisms."); - } - }).withConsistencyLevel(ConsistencyLevel.QUORUM).run().get(); - Result> updatedObjsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - Result> updatedObjsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, - updatedObjsT, updatedObjsA); - } - } - - @Test - public void testDataUpdateMultiVectors() throws ExecutionException, InterruptedException { - WeaviateClient syncClient = new WeaviateClient(new Config("http", address)); - try (WeaviateAsyncClient client = syncClient.async()) { - - // Arrange: Configure collection and create it - String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()).build()) - .vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = - client.schema().classCreator().withClass(weaviateClass).run().get(); - assumeTrue(createResult.getResult(), "schema created successfully"); - - String id = UUID.randomUUID().toString(); - Float[][] colbertVector = - new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, - {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; - - Result insertResult = client.data().creator().withID(id) - .withClassName(className).withProperties(new HashMap() { - { - this.put("name", "TestObject-1"); - } - }).withMultiVectors(new HashMap() { - { - this.put("colbert", colbertVector); - } - }).run().get(); - assumeFalse(insertResult.hasErrors(), "test data inserted successfully"); - - // Act: Update data - Float[][] newVector = Arrays.stream(colbertVector) - .map(inner -> Arrays.stream(inner).map(v -> 5 * v).toArray(Float[]::new)) - .toArray(Float[][]::new); - Result updateResult = client.data().updater().withID(id).withClassName(className) - .withMultiVectors(new HashMap() { - { - this.put("colbert", newVector); - } - }).run().get(); - assertNull("successfully updated metadata", updateResult.getError()); - - // Assert: Retrieve object and check metadata - Result> getResult = client.data().objectsGetter() - .withClassName(className).withID(id).withVector().run().get(); - - Assertions.assertThat(getResult).isNotNull().returns(null, Result::getError) - .as("get object error").extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object").satisfies(o -> { - Assertions.assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() - .containsOnlyKeys("colbert").satisfies(multi -> { - Assertions.assertThat(multi.get("colbert")).as("colbert multivector") - .isEqualTo(newVector); - }); - }).as("expected updated object metadata"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(syncClient); - } - } - - @Test - public void testDataMerge() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataMerge.objTID; - String objAID = DataTestSuite.testDataMerge.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataMerge.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataMerge.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - Result mergeObjectT = client.data().updater().withClassName("Pizza").withID(objTID) - .withProperties(new HashMap() { - { - put("description", "Universally accepted to be the best pizza ever created."); - } - }).withMerge().run().get(); - Result mergeObjectA = client.data().updater().withClassName("Soup").withID(objAID) - .withProperties(new HashMap() { - { - put("description", - "Used by humans when their inferior genetics are attacked by microscopic organisms."); - } - }).withMerge().run().get(); - Result> mergedObjsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run().get(); - Result> mergeddObjsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, - mergedObjsT, mergeddObjsA); - } - } - - @Test - public void testDataValidate() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataValidate.objTID; - String objAID = DataTestSuite.testDataValidate.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataValidate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataValidate.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result validateObjT = client.data().validator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result validateObjA = client.data().validator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - propertiesSchemaT.put("test", "not existing property"); - Result validateObjT1 = client.data().validator().withClassName("Pizza") - .withID(objTID).withProperties(propertiesSchemaT).run().get(); - propertiesSchemaA.put("test", "not existing property"); - Result validateObjA1 = client.data().validator().withClassName("Pizza") - .withID(objTID).withProperties(propertiesSchemaT).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, - validateObjA1); - } - } - - @Test - public void testDataGetWithAdditionalError() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataGetWithAdditionalError.objTID; - String objAID = DataTestSuite.testDataGetWithAdditionalError.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) - .withClassName("Pizza").withAdditional("featureProjection").withVector().run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataGetWithAdditionalError.assertResults(objectT, objectA, objsAdditionalT); - } - } - - @Test - public void testDataCreateWithArrayType() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateClass clazz = DataTestSuite.testDataCreateWithArrayType.clazz; - String objTID = DataTestSuite.testDataCreateWithArrayType.objTID; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result objectT = client.data().creator().withClassName("ClassArrays") - .withID(objTID).withProperties(propertiesSchemaT).run().get(); - Result> objectsT = - client.data().objectsGetter().withClassName("ClassArrays").withID(objTID).run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - // then - DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, - objectT, objectsT, deleteStatus, schemaAfterDelete); - } - } - - @Test - public void testDataGetWithVector() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateClass clazz = DataTestSuite.testDataGetWithVector.clazz; - String objTID = DataTestSuite.testDataGetWithVector.objTID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithVector.propertiesSchemaT(); - Float[] vectorObjT = DataTestSuite.testDataGetWithVector.vectorObjT; - try (WeaviateAsyncClient client = syncClient.async()) { - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result objectT = client.data().creator().withClassName("ClassCustomVector") - .withID(objTID).withVector(vectorObjT).withProperties(propertiesSchemaT).run().get(); - Result> objT = client.data().objectsGetter() - .withClassName("ClassCustomVector").withID(objTID).withVector().run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - // then - DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, - objT, deleteStatus, schemaAfterDelete); - } - } - - @Test - public void testObjectCheck() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testObjectCheck.objTID; - String objAID = DataTestSuite.testObjectCheck.objAID; - String nonExistentObjectID = DataTestSuite.testObjectCheck.nonExistentObjectID; - Map propertiesSchemaT = - DataTestSuite.testObjectCheck.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testObjectCheck.propertiesSchemaA(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run().get(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run().get(); - // check object existence - Result checkObjT = - client.data().checker().withClassName("Pizza").withID(objTID).run().get(); - Result checkObjA = - client.data().checker().withClassName("Soup").withID(objAID).run().get(); - Result> objA = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withVector().run().get(); - Result> objT = client.data().objectsGetter().withID(objTID) - .withClassName("Pizza").withVector().run().get(); - Result checkNonexistentObject = - client.data().checker().withClassName("Pizza").withID(nonExistentObjectID).run().get(); - // delete all objects from Weaviate - Result deleteStatus = client.schema().allDeleter().run().get(); - // check object's existence status after clean up - Result checkObjTAfterDelete = - client.data().checker().withClassName("Pizza").withID(objTID).run().get(); - Result checkObjAAfterDelete = - client.data().checker().withClassName("Soup").withID(objAID).run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testObjectCheck.assertResults(objectT, objectA, checkObjT, checkObjA, objA, - objT, checkNonexistentObject, deleteStatus, checkObjTAfterDelete, checkObjAAfterDelete); - } - } - - @Test - public void testDataCreateWithIDInNotUUIDFormat() - throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - String objID = DataTestSuite.testDataCreateWithIDInNotUUIDFormat.objID; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.propertiesSchemaT(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - Result objectT = client.data().creator().withID(objID).withClassName("Pizza") - .withProperties(propertiesSchemaT).run().get(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objID).run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - // then - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, - deleteStatus, schemaAfterDelete); - } - } - - @Test - public void testDataGetUsingClassParameter() throws ExecutionException, InterruptedException { - // given - Config config = new Config("http", address); - WeaviateClient syncClient = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - try (WeaviateAsyncClient client = syncClient.async()) { - // when - testGenerics.createWeaviateTestSchemaFoodAsync(client); - Result pizzaObj1 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Margherita"); - put("description", "plain"); - } - }).run().get(); - Result pizzaObj2 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Pepperoni"); - put("description", "meat"); - } - }).run().get(); - Result soupObj1 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Chicken"); - put("description", "plain"); - } - }).run().get(); - Result soupObj2 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Tofu"); - put("description", "vegetarian"); - } - }).run().get(); - Result> objects = client.data().objectsGetter().run().get(); - Result> pizzaObjects = - client.data().objectsGetter().withClassName("Pizza").run().get(); - Result> soupObjects = - client.data().objectsGetter().withClassName("Soup").run().get(); - testGenerics.cleanupWeaviateAsync(client); - // then - DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, - soupObj2, objects, pizzaObjects, soupObjects); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/data/ClientReferencesTest.java b/src/test/java/io/weaviate/integration/client/async/data/ClientReferencesTest.java deleted file mode 100644 index 8fb2246e0..000000000 --- a/src/test/java/io/weaviate/integration/client/async/data/ClientReferencesTest.java +++ /dev/null @@ -1,337 +0,0 @@ -package io.weaviate.integration.client.async.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.data.model.ObjectReference; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutionException; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientReferencesTest { - private String address; - private WeaviateClient syncClient; - - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - - Config config = new Config("http", address); - syncClient = new WeaviateClient(config); - - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(syncClient); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(syncClient); - } - - @Test - public void testDataCreateWithReferenceCreate() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run().get(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run().get(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run().get(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - } - } - - @Test - public void testDataCreateWithReferenceReplace() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // when - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run().get(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run().get(); - // Thing -> Action - // Payload to reference the ChickenSoup - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run().get(); - // Action -> Thing - // Payload to reference the Hawaii - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run().get(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run().get(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - // Replace the above reference with self references - // Thing -> Thing - client.data().referenceReplacer() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ hawaiiRef }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - // Action -> Action - client.data().referenceReplacer() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ chickenSoupRef }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result> thingsReplaced = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run().get(); - Result> actionsReplaced = client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - // check objT replaced - checkReference(thingsReplaced, "Pizza", objTID); - // check objA replaced - checkReference(actionsReplaced, "Soup", objAID); - } - } - - @Test - public void testDataCreateWithReferenceDelete() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run().get(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run().get(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run().get(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run().get(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run().get(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - // Delete ref - Result otherFoodsPizzaRefDelete = client.data().referenceDeleter() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - Result otherFoodsSoupRefDelete = client.data().referenceDeleter() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run().get(); - // Get the objects - Result> thingsAfterRefDelete = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run().get(); - Result> actionsAfterRefDelete = client.data().objectsGetter().withID(objAID).withClassName("Soup").run().get(); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - // check ref delete - assertNotNull(otherFoodsPizzaRefDelete); - assertNull(otherFoodsPizzaRefDelete.getError()); - assertTrue(otherFoodsPizzaRefDelete.getResult()); - assertNotNull(otherFoodsSoupRefDelete); - assertNull(otherFoodsSoupRefDelete.getError()); - assertTrue(otherFoodsSoupRefDelete.getResult()); - // check objT after delete, should be null - checkReference(thingsAfterRefDelete, null, null); - // check objA after delete, should be null - checkReference(actionsAfterRefDelete, null, null); - } - } - - @Test - public void testDataCreateWithAddReferenceUsingProperties() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objRefBeaconID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba92"; - Map propertiesSchemaRefBeacon = new HashMap() {{ - put("name", "RefBeaconSoup"); - put("description", "Used only to check if reference can be added."); - put("otherFoods", new ObjectReference[]{ - ObjectReference.builder().beacon("weaviate://localhost/Pizza/abefd256-8574-442b-9293-9205193737ee").build() - }); - }}; - // when - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run().get(); - // create object with a reference to objT - Result objRefBeaconCreate = client.data().creator() - .withClassName("Soup") - .withID(objRefBeaconID) - .withProperties(propertiesSchemaRefBeacon) - .run().get(); - // Get the object reference beacon to check if otherFoods reference has been set - Result> objRefBeaconGet = client.data().objectsGetter().withID(objRefBeaconID).withClassName("Soup").run().get(); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objRefBeaconCreate); - assertNull(objRefBeaconCreate.getError()); - // check objT - checkReference(objRefBeaconGet, "Pizza", objTID); - } - } - - @SuppressWarnings("unchecked") - private void checkReference(Result> result, String className, String refID) { - assertNotNull(result); - assertNull(result.getError()); - assertNotNull(result.getResult()); - assertNotNull(result.getResult().get(0)); - assertNotNull(result.getResult().get(0).getProperties()); - assertNotNull(result.getResult().get(0).getProperties().get("otherFoods")); - assertTrue(result.getResult().get(0).getProperties().get("otherFoods") instanceof List); - List> resultOtherFoods = (List>) result.getResult().get(0).getProperties().get("otherFoods"); - if (refID != null) { - assertTrue(resultOtherFoods.size() > 0); - assertNotNull(resultOtherFoods.get(0)); - Map propOtherFoods = resultOtherFoods.get(0); - assertEquals(propOtherFoods.get("beacon"), "weaviate://localhost/"+className+"/"+refID); - assertEquals(propOtherFoods.get("href"), "/v1/objects/"+className+"/"+refID); - } else { - assertEquals(resultOtherFoods.size(), 0); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/AbstractAsyncClientTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/AbstractAsyncClientTest.java deleted file mode 100644 index c21a0c35f..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/AbstractAsyncClientTest.java +++ /dev/null @@ -1,102 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.graphql.AbstractClientGraphQLTest; - -import java.util.Date; -import java.util.Map; - -import static org.junit.Assert.assertNull; -import static org.junit.jupiter.api.Assertions.assertNotNull; - -class AbstractAsyncClientTest extends AbstractClientGraphQLTest { - static Field field(String name) { - return Field.builder().name(name).build(); - } - - static Field[] fields(String... fieldNames) { - Field[] fields = new Field[fieldNames.length]; - for (int i = 0; i < fieldNames.length; i++) { - fields[i] = field(fieldNames[i]); - } - return fields; - } - - static Field _additional(String... fieldNames) { - return Field.builder().name("_additional").fields(fields(fieldNames)).build(); - } - - static Field meta(String... fieldNames) { - return Field.builder().name("meta").fields(fields(fieldNames)).build(); - } - - - static WhereArgument whereText(String property, String operator, String... valueText) { - return WhereArgument.builder() - .filter(WhereFilter.builder() - .path(property) - .operator(operator) - .valueText(valueText) - .build()) - .build(); - } - - static WhereArgument whereDate(String property, String operator, Date... valueDate) { - return WhereArgument.builder() - .filter(WhereFilter.builder() - .path(property) - .operator(operator) - .valueDate(valueDate) - .build()) - .build(); - } - - static WhereArgument whereNumber(String property, String operator, Double... valueNumber) { - return WhereArgument.builder() - .filter(WhereFilter.builder() - .path(property) - .operator(operator) - .valueNumber(valueNumber) - .build()) - .build(); - } - - /** - * Check that request was processed successfully and no errors are returned. Extract the part of the response body for the specified query type. - * - * @param result Result of a GraphQL query. - * @param queryType "Get", "Explore", or "Aggregate". - * @return "data" portion of the response - */ - @SuppressWarnings("unchecked") - T extractQueryResult(Result result, String queryType) { - assertNotNull(result, "graphQL request returned null"); - assertNull("GraphQL error in the response", result.getError()); - - GraphQLResponse resp = result.getResult(); - assertNotNull(resp, "GraphQL response not returned"); - - Map data = (Map) resp.getData(); - assertNotNull(data, "GraphQL response has no data"); - - T queryResult = (T) data.get(queryType); - assertNotNull(queryResult, String.format("%s query returned no result", queryType)); - - return queryResult; - } - - T extractClass(Result result, String queryType, String className) { - Map queryResult = extractQueryResult(result, queryType); - return extractClass(queryResult, className); - } - - T extractClass(Map queryResult, String className) { - T objects = queryResult.get(className); - assertNotNull(objects, String.format("no %ss returned", className.toLowerCase())); - return objects; - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTargetSearchTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTargetSearchTest.java deleted file mode 100644 index 0c75178eb..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTargetSearchTest.java +++ /dev/null @@ -1,344 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.graphql.GraphQL; -import io.weaviate.client.v1.async.graphql.api.Get; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.Targets; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.PQConfig; -import io.weaviate.client.v1.misc.model.SQConfig; -import io.weaviate.client.v1.misc.model.RQConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.*; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import static org.junit.Assert.assertNull; -import static org.junit.jupiter.api.Assertions.fail; - -public class ClientGraphQLMultiTargetSearchTest extends AbstractAsyncClientTest { - private String httpHost; - private String grpcHost; - - private WeaviateClient syncClient; - private WeaviateAsyncClient client; - private GraphQL gql; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - httpHost = compose.getHttpHostAddress(); - - Config config = new Config("http", httpHost); - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - syncClient = new WeaviateClient(config); - - client = syncClient.async(); - gql = client.graphQL(); - } - - @After - public void after() { - client.close(); - } - - private final String id1 = "00000000-0000-0000-0000-000000000001"; - private final String id2 = "00000000-0000-0000-0000-000000000002"; - private final String id3 = "00000000-0000-0000-0000-000000000003"; - - private final String titleAndContent = "titleAndContent"; - private final String title1 = "title1"; - private final String title2 = "title2"; - private final String title3 = "title3"; - private final String bringYourOwnVector = "bringYourOwnVector"; - private final String bringYourOwnVector2 = "bringYourOwnVector2"; - - @Test - public void shouldPerformMultiTargetSearch() throws InterruptedException { - String className = "MultiTargetSearch"; - setupDB(className); - Field _additional = _additional("id", "distance"); - // nearText - Map weights = new HashMap<>(); - weights.put(titleAndContent, 0.1f); - weights.put(title1, 0.6f); - weights.put(title2, 0.3f); - weights.put(title3, 0.1f); - Targets targets = - Targets.builder().targetVectors(new String[] {titleAndContent, title1, title2, title3}) - .combinationMethod(Targets.CombinationMethod.manualWeights).weights(weights).build(); - NearTextArgument nearText = gql.arguments().nearTextArgBuilder() - .concepts(new String[] {"Water black"}).targets(targets).build(); - Result response = - doGet(get -> get.withClassName(className).withNearText(nearText).withFields(_additional)); - assertGetContainsIds(response, className, id1, id2, id3); - // nearVector with single vector-per-target - Map vectorPerTarget = new HashMap<>(); - vectorPerTarget.put(bringYourOwnVector, new Float[] {.99f, .88f, .77f}); - vectorPerTarget.put(bringYourOwnVector2, new Float[] {.11f, .22f, .33f}); - weights = new HashMap() { - { - this.put(bringYourOwnVector, 0.1f); - this.put(bringYourOwnVector2, 0.6f); - } - }; - targets = - Targets.builder().targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2}) - .combinationMethod(Targets.CombinationMethod.manualWeights).weights(weights).build(); - final NearVectorArgument nearVector1 = gql.arguments().nearVectorArgBuilder() - .vectorPerTarget(vectorPerTarget).targets(targets).build(); - response = doGet( - get -> get.withClassName(className).withNearVector(nearVector1).withFields(_additional)); - assertNull("check error in response:", response.getError()); - assertGetContainsIds(response, className, id2, id3); - // nearVector with multiple vector-per-target - Map vectorsPerTarget = new HashMap<>(); - vectorsPerTarget.put(bringYourOwnVector, - new Float[][] {new Float[] {.99f, .88f, .77f}, new Float[] {.99f, .88f, .77f}}); - vectorsPerTarget.put(bringYourOwnVector2, new Float[][] {new Float[] {.11f, .22f, .33f}}); - Map weightsMulti = new HashMap<>(); - weightsMulti.put(bringYourOwnVector, new Float[] {0.5f, 0.5f}); - weightsMulti.put(bringYourOwnVector2, new Float[] {0.6f}); - targets = - Targets.builder().targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2}) - .combinationMethod(Targets.CombinationMethod.manualWeights).weightsMulti(weightsMulti) - .build(); - final NearVectorArgument nearVector2 = gql.arguments().nearVectorArgBuilder() - .vectorsPerTarget(vectorsPerTarget).targets(targets).build(); - response = doGet( - get -> get.withClassName(className).withNearVector(nearVector2).withFields(_additional)); - assertNull("check error in response:", response.getError()); - assertGetContainsIds(response, className, id2, id3); - // nearObject - targets = Targets - .builder().targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2, - titleAndContent, title1, title2, title3}) - .combinationMethod(Targets.CombinationMethod.average).build(); - NearObjectArgument nearObject = - gql.arguments().nearObjectArgBuilder().id(id3).targets(targets).build(); - response = doGet( - get -> get.withClassName(className).withNearObject(nearObject).withFields(_additional)); - assertGetContainsIds(response, className, id2, id3); - } - - private void setupDB(String className) { - // clean - Result delete = syncClient.schema().allDeleter().run(); - assertThat(delete).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - // create class - List properties = Arrays.asList( - Property.builder().name("title").dataType(Collections.singletonList(DataType.TEXT)).build(), - Property.builder().name("content").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("title1").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("title2").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("title3").dataType(Collections.singletonList(DataType.TEXT)) - .build()); - Map vectorConfig = new HashMap<>(); - vectorConfig.put(titleAndContent, getTitleAndContentVectorConfig()); - vectorConfig.put(title1, getTitle1VectorConfig()); - vectorConfig.put(title2, getTitle2VectorConfig()); - vectorConfig.put(title3, getTitle3VectorConfig()); - vectorConfig.put(bringYourOwnVector, getBringYourOwnVectorVectorConfig()); - vectorConfig.put(bringYourOwnVector2, getBringYourOwnVectorVectorConfig2()); - Result createResult = - syncClient.schema().classCreator().withClass(WeaviateClass.builder().className(className) - .properties(properties).vectorConfig(vectorConfig).build()).run(); - assertThat(createResult).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - // add data - // obj1 - Map props1 = new HashMap<>(); - props1.put("title", "The Lord of the Rings"); - props1.put("content", "A great fantasy novel"); - props1.put("title1", "J.R.R. Tolkien The Lord of the Rings"); - props1.put("title2", "Rings"); - props1.put("title3", "Book"); - Float[] vector1a = new Float[] {0.77f, 0.88f, 0.77f}; - Map vectors1 = new HashMap<>(); - vectors1.put("bringYourOwnVector", vector1a); - // don't add vector for bringYourOwnVector2 - // obj2 - Map props2 = new HashMap<>(); - props2.put("title", "Black Oceans"); - props2.put("content", "A great science fiction book"); - props2.put("title1", "Jacek Dukaj Black Oceans"); - props2.put("title2", "Water"); - props2.put("title3", "Book"); - Float[] vector2a = new Float[] {0.11f, 0.22f, 0.33f}; - Float[] vector2b = new Float[] {0.11f, 0.11f, 0.11f}; - Map vectors2 = new HashMap<>(); - vectors2.put("bringYourOwnVector", vector2a); - vectors2.put("bringYourOwnVector2", vector2b); - // obj2 - Map props3 = new HashMap<>(); - props3.put("title", "Into the Water"); - props3.put("content", - "New York Times bestseller and global phenomenon The Girl on the Train returns with Into the Water"); - props3.put("title1", "Paula Hawkins Into the Water"); - props3.put("title2", "Water go into it"); - props3.put("title3", "Book"); - Float[] vector3a = new Float[] {0.99f, 0.88f, 0.77f}; - Float[] vector3b = new Float[] {0.99f, 0.88f, 0.77f}; - Map vectors3 = new HashMap<>(); - vectors3.put("bringYourOwnVector", vector3a); - vectors3.put("bringYourOwnVector2", vector3b); - - WeaviateObject obj1 = createObject(id1, className, props1, vectors1); - WeaviateObject obj2 = createObject(id2, className, props2, vectors2); - WeaviateObject obj3 = createObject(id3, className, props3, vectors3); - - Result result = - syncClient.batch().objectsBatcher().withObjects(obj1, obj2, obj3).run(); - - assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .asInstanceOf(ARRAY).hasSize(3); - } - - private WeaviateClass.VectorConfig getTitleAndContentVectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title", "content"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWSQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle1VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title1"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWPQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle2VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title2"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle3VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title3"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWRQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getBringYourOwnVectorVectorConfig() { - Map byov = new HashMap<>(); - byov.put("none", new Object()); - return getFlatBQVectorConfig(byov); - } - - private WeaviateClass.VectorConfig getBringYourOwnVectorVectorConfig2() { - Map byov = new HashMap<>(); - byov.put("none", new Object()); - return getFlatVectorConfig(byov); - } - - private WeaviateClass.VectorConfig getFlatBQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("flat").vectorizer(vectorizerConfig) - .vectorIndexConfig( - VectorIndexConfig.builder().bq(BQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getFlatVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("flat").vectorizer(vectorizerConfig) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw").vectorizer(vectorizerConfig) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWPQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw").vectorizer(vectorizerConfig) - .vectorIndexConfig( - VectorIndexConfig.builder().pq(PQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWSQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw").vectorizer(vectorizerConfig) - .vectorIndexConfig( - VectorIndexConfig.builder().sq(SQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWRQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw").vectorizer(vectorizerConfig) - .vectorIndexConfig( - VectorIndexConfig.builder().rq(RQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateObject createObject(String id, String className, Map props, - Map vectors) { - WeaviateObject.WeaviateObjectBuilder obj = - WeaviateObject.builder().id(id).className(className).properties(props); - if (vectors != null) { - obj = obj.vectors(vectors); - } - return obj.build(); - } - - @SuppressWarnings("unchecked") - private void assertGetContainsIds(Result response, String className, - String... expectedIds) { - assertThat(response).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .isNotNull().extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).isInstanceOf(List.class) - .asList().hasSize(expectedIds.length) - .extracting(obj -> ((Map) obj).get("_additional")) - .extracting(add -> ((Map) add).get("id")) - .containsExactlyInAnyOrder((Object[]) expectedIds); - } - - private Result doGet(Consumer build) { - Get get = gql.get(); - build.accept(get); - try { - return get.run().get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.get(): " + e.getMessage()); - return null; - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTenancyTest.java deleted file mode 100644 index 1e5aed31f..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLMultiTenancyTest.java +++ /dev/null @@ -1,269 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.graphql.GraphQL; -import io.weaviate.client.v1.async.graphql.api.Aggregate; -import io.weaviate.client.v1.async.graphql.api.Get; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import org.assertj.core.api.AbstractObjectAssert; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; - -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_1; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_2; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.fail; - -public class ClientGraphQLMultiTenancyTest extends AbstractAsyncClientTest { - private static final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - private String address; - - private WeaviateClient syncClient; - private WeaviateAsyncClient client; - private GraphQL gql; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - - syncClient = new WeaviateClient(new Config("http", address)); - - testGenerics.createSchemaPizzaForTenants(syncClient); - testGenerics.createTenantsPizza(syncClient, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(syncClient, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(syncClient, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(syncClient, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(syncClient, TENANT_2.getName()); - - client = syncClient.async(); - gql = client.graphQL(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(syncClient); - client.close(); - } - - @Test - public void shouldGetAllDataForTenant() { - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_HAWAII_ID, - WeaviateTestGenerics.PIZZA_DOENER_ID, - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = doGet(get -> get - .withTenant(tenant) - .withClassName("Pizza") - .withFields(_additional("id"))); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldGetLimitedDataForTenant() { - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_HAWAII_ID, - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = doGet(get -> get - .withTenant(tenant) - .withClassName("Pizza") - .withLimit(1) - .withFields(_additional("id"))); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldGetFilteredDataForTenant() { - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = doGet(get -> get - .withTenant(tenant) - .withClassName("Pizza") - .withWhere(whereNumber("price", Operator.GreaterThan, 2.0d)) - .withFields(_additional("id"))); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldAggregateAllDataForTenant() { - Map> expectedAggValuesByTenant = new HashMap<>(); - expectedAggValuesByTenant.put(TENANT_1.getName(), new HashMap() {{ - put("count", 2.0); - put("maximum", 2.5); - put("minimum", 1.4); - put("median", 1.95); - put("mean", 1.95); - put("mode", 1.4); - put("sum", 3.9); - }}); - expectedAggValuesByTenant.put(TENANT_2.getName(), new HashMap() {{ - put("count", 2.0); - put("maximum", 1.2); - put("minimum", 1.1); - put("median", 1.15); - put("mean", 1.15); - put("mode", 1.1); - put("sum", 2.3); - }}); - - expectedAggValuesByTenant.forEach((tenant, expectedAggValues) -> { - Result response = doAggregate(aggregate -> aggregate - .withTenant(tenant) - .withClassName("Pizza") - .withFields(Field.builder() - .name("price") - .fields(fields( - "count", - "maximum", - "minimum", - "median", - "mean", - "mode", - "sum" - )).build())); - - assertAggregateNumFieldHasValues(response, "Pizza", "price", expectedAggValues); - }); - } - - @Test - public void shouldAggregateFilteredDataForTenant() { - Map> expectedAggValuesByTenant = new HashMap<>(); - expectedAggValuesByTenant.put(TENANT_1.getName(), new HashMap() {{ - put("count", 1.0); - put("maximum", 2.5); - put("minimum", 2.5); - put("median", 2.5); - put("mean", 2.5); - put("mode", 2.5); - put("sum", 2.5); - }}); - expectedAggValuesByTenant.put(TENANT_2.getName(), new HashMap() {{ - put("count", 0.0); - put("maximum", null); - put("minimum", null); - put("median", null); - put("mean", null); - put("mode", null); - put("sum", null); - }}); - - expectedAggValuesByTenant.forEach((tenant, expectedAggValues) -> { - Result response = doAggregate(aggregate -> aggregate - .withTenant(tenant) - .withClassName("Pizza") - .withWhere(whereNumber("price", Operator.GreaterThan, 2.0d)) - .withFields(Field.builder() - .name("price") - .fields(fields( - "count", - "maximum", - "minimum", - "median", - "mean", - "mode", - "sum" - )).build())); - - assertAggregateNumFieldHasValues(response, "Pizza", "price", expectedAggValues); - }); - } - - @SuppressWarnings("unchecked") - private void assertGetContainsIds(Result response, String className, String... expectedIds) { - assertThat(response).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).isInstanceOf(List.class).asList() - .hasSize(expectedIds.length) - .extracting(obj -> ((Map) obj).get("_additional")) - .extracting(add -> ((Map) add).get("id")) - .containsExactlyInAnyOrder((Object[]) expectedIds); - } - - @SuppressWarnings("unchecked") - private void assertAggregateNumFieldHasValues( - Result response, String className, String fieldName, - Map expectedAggValues - ) { - AbstractObjectAssert aggregate = assertThat(response).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Aggregate")).isInstanceOf(Map.class) - .extracting(agg -> ((Map) agg).get(className)).isInstanceOf(List.class).asList() - .hasSize(1) - .first() - .extracting(obj -> ((Map) obj).get(fieldName)).isInstanceOf(Map.class); - - expectedAggValues.forEach((name, value) -> aggregate.returns(value, map -> ((Map) map).get(name))); - } - - private Result doGet(Consumer build) { - Get get = gql.get(); - build.accept(get); - try { - return get.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.get(): " + e.getMessage()); - return null; - } - } - - private Result doAggregate(Consumer build) { - Aggregate aggregate = gql.aggregate(); - build.accept(aggregate); - try { - return aggregate.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.aggregate(): " + e.getMessage()); - return null; - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTest.java deleted file mode 100644 index 7ea809492..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTest.java +++ /dev/null @@ -1,1197 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import static org.junit.Assert.fail; -import static org.junit.Assume.assumeTrue; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; - -import org.assertj.core.api.Assertions; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Ignore; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.graphql.GraphQL; -import io.weaviate.client.v1.async.graphql.api.Aggregate; -import io.weaviate.client.v1.async.graphql.api.Explore; -import io.weaviate.client.v1.async.graphql.api.Get; -import io.weaviate.client.v1.async.graphql.api.Raw; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.graphql.model.ExploreFields; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupType; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.v1.graphql.query.argument.SortOrder; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; - -public class ClientGraphQLTest extends AbstractAsyncClientTest { - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - private final WeaviateTestGenerics.DocumentPassageSchema passageSchema = new WeaviateTestGenerics.DocumentPassageSchema(); - - private String address; - private WeaviateClient syncClient; - private WeaviateAsyncClient client; - private GraphQL gql; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - - syncClient = new WeaviateClient(new Config("http", address)); - testGenerics.createTestSchemaAndData(syncClient); - - client = syncClient.async(); - gql = client.graphQL(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(syncClient); - client.close(); - } - - @Test - public void testGraphQLGet() { - Result result = doGet(get -> get.withClassName("Pizza") - .withFields(field("name"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(4, pizzas.size(), "wrong number of pizzas returned"); - } - - @Test - public void testGraphQLRaw() { - String query = "{Get{Pizza{_additional{id}}}}"; - - Result result = doRaw(raw -> raw.withQuery(query)); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(4, pizzas.size(), "wrong number of pizzas returned"); - } - - @Test - public void testGraphQLGetWithNearObjectAndCertainty() { - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - NearObjectArgument nearObjectArgument = gql.arguments() - .nearObjectArgBuilder() - .id(newObjID) - .certainty(0.99f) - .build(); - - WeaviateObject soupWithID = WeaviateObject.builder() - .className("Soup") - .id(newObjID) - .properties(new HashMap() { - { - put("name", "JustSoup"); - put("description", "soup with id"); - } - }) - .build(); - - // Insert additional test data - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(soupWithID) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 1); - - Result result = doGet(get -> get.withClassName("Soup") - .withNearObject(nearObjectArgument) - .withFields(field("name"), _additional("certainty"))); - - List soups = extractClass(result, "Get", "Soup"); - assertEquals(1, soups.size(), "wrong number of soups"); - } - - @Test - public void testGraphQLGetWithNearObjectAndDistance() { - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - NearObjectArgument nearObjectArgument = gql.arguments() - .nearObjectArgBuilder() - .id(newObjID) - .distance(0.1f) - .build(); - - WeaviateObject soupWithID = WeaviateObject.builder() - .className("Soup") - .id(newObjID) - .properties(new HashMap() { - { - put("name", "JustSoup"); - put("description", "soup with id"); - } - }) - .build(); - - // Insert additional test data - syncClient.batch() - .objectsBatcher() - .withObjects(soupWithID) - .run(); - - Result result = doGet(get -> get.withClassName("Soup") - .withNearObject(nearObjectArgument) - .withFields(field("name"), _additional("distance"))); - - List soups = extractClass(result, "Get", "Soup"); - assertEquals(1, soups.size(), "wrong number of soups"); - } - - @Test - @SuppressWarnings("unchecked") - public void testBm25() { - Bm25Argument bm25 = gql.arguments() - .bm25ArgBuilder() - .query("innovation") - .properties(new String[] { "description" }) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withBm25(bm25) - .withFields(field("description"), _additional("id", "distance"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - - Map pizza = (Map) pizzas.get(0); - assertTrue(((String) pizza.get("description")).contains("innovation"), "wrong Pizza description"); - } - - @Test - public void testHybrid() { - HybridArgument hybrid = gql.arguments() - .hybridArgBuilder() - .query("some say revolution") - .alpha(0.8f) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withHybrid(hybrid) - .withFields(field("description"), _additional("id"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertFalse(pizzas.isEmpty(), "didn't get any pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndCertainty() { - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[] { "Universally" }) - .force(0.8f) - .build(); - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .moveAwayFrom(moveAway) - .certainty(0.8f) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withFields(field("name"), _additional("certainty"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndDistance() { - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[] { "Universally" }) - .force(0.8f) - .build(); - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .moveAwayFrom(moveAway) - .distance(0.4f) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withFields(field("name"), _additional("distance"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndMoveParamsAndCertainty() { - String newObjID1 = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - String newObjID2 = "6baed48e-2afe-4be4-a09d-b00a955d962a"; - WeaviateObject pizzaWithID = WeaviateObject.builder() - .className("Pizza") - .id(newObjID1) - .properties(new HashMap() { - { - put("name", "JustPizza1"); - put("description", "Universally pizza with id"); - } - }) - .build(); - WeaviateObject pizzaWithID2 = WeaviateObject.builder() - .className("Pizza") - .id(newObjID2) - .properties(new HashMap() { - { - put("name", "JustPizza2"); - put("description", "Universally pizza with some other id"); - } - }) - .build(); - - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { NearTextMoveParameters.ObjectMove.builder() - .id(newObjID1).build() - }) - .force(0.9f) - .build(); - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { NearTextMoveParameters.ObjectMove.builder() - .id(newObjID2).build() - }) - .force(0.9f) - .build(); - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "Universally pizza with id" }) - .moveAwayFrom(moveAway) - .moveTo(moveTo) - .certainty(0.4f) - .build(); - - // Insert additional test data - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(pizzaWithID, pizzaWithID2) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 2); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withFields(field("name"), _additional("certainty"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(6, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndMoveParamsAndDistance() { - String newObjID1 = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - String newObjID2 = "6baed48e-2afe-4be4-a09d-b00a955d962a"; - WeaviateObject pizzaWithID = WeaviateObject.builder() - .className("Pizza") - .id(newObjID1) - .properties(new HashMap() { - { - put("name", "JustPizza1"); - put("description", "Universally pizza with id"); - } - }) - .build(); - WeaviateObject pizzaWithID2 = WeaviateObject.builder() - .className("Pizza") - .id(newObjID2) - .properties(new HashMap() { - { - put("name", "JustPizza2"); - put("description", "Universally pizza with some other id"); - } - }) - .build(); - - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { NearTextMoveParameters.ObjectMove.builder() - .id(newObjID1).build() - }) - .force(0.9f) - .build(); - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { NearTextMoveParameters.ObjectMove.builder() - .id(newObjID2).build() - }) - .force(0.9f) - .build(); - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "Universally pizza with id" }) - .moveAwayFrom(moveAway) - .moveTo(moveTo) - .distance(0.6f) - .build(); - - // Insert additional test data - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(pizzaWithID, pizzaWithID2) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 2); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withFields(field("name"), _additional("distance"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(6, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndLimitAndCertainty() { - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .certainty(0.8f) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withLimit(1) - .withFields(field("name"), _additional("certainty"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithNearTextAndLimitAndDistance() { - NearTextArgument nearText = gql.arguments() - .nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .distance(0.4f) - .build(); - - Result result = doGet(get -> get.withClassName("Pizza") - .withNearText(nearText) - .withLimit(1) - .withFields(field("name"), _additional("distance"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithWhereByFieldTokenizedProperty() { - Field name = field("name"); - WhereArgument whereFullString = whereText("name", Operator.Equal, "Frutti di Mare"); - WhereArgument wherePartString = whereText("name", Operator.Equal, "Frutti"); - WhereArgument whereFullText = whereText("description", Operator.Equal, - "Universally accepted to be the best pizza ever created."); - WhereArgument wherePartText = whereText("description", Operator.Equal, "Universally"); - // when - Result resultFullString = doGet(get -> get.withWhere(whereFullString) - .withClassName("Pizza") - .withFields(name)); - Result resultPartString = doGet(get -> get.withWhere(wherePartString) - .withClassName("Pizza") - .withFields(name)); - Result resultFullText = doGet(get -> get.withWhere(whereFullText) - .withClassName("Pizza") - .withFields(name)); - Result resultPartText = doGet(get -> get.withWhere(wherePartText) - .withClassName("Pizza") - .withFields(name)); - // then - assertWhereResultSize(1, resultFullString, "Pizza"); - assertWhereResultSize(0, resultPartString, "Pizza"); - assertWhereResultSize(1, resultFullText, "Pizza"); - assertWhereResultSize(1, resultPartText, "Pizza"); - } - - @Test - public void shouldSupportDeprecatedValueString() { - WhereArgument whereString = whereText("name", Operator.Equal, "Frutti di Mare"); - - Result result = doGet(get -> get.withWhere(whereString) - .withClassName("Pizza") - .withFields(field("name"))); - - assertWhereResultSize(1, result, "Pizza"); - } - - @Test - public void testGraphQLGetWithWhereByDate() { - Calendar cal = Calendar.getInstance(); - cal.set(2022, Calendar.FEBRUARY, 1, 0, 0, 0); - WhereArgument whereDate = whereDate("bestBefore", Operator.GreaterThan, cal.getTime()); - - Result resultDate = doGet(get -> get.withWhere(whereDate) - .withClassName("Pizza") - .withFields(field("name"))); - - List> result = extractClass(resultDate, "Get", "Pizza"); - Assertions.assertThat(result) - .hasSize(3) - .extracting(el -> (String) el.get("name")) - .contains("Frutti di Mare", "Hawaii", "Doener"); - } - - /** - * @see https://github.com/weaviate/java-client/pull/456#issuecomment-3270249876 - */ - @Ignore("Regression in Explorer API in v1.33") - @Test - public void testGraphQLExploreWithCertainty() { - ExploreFields[] fields = new ExploreFields[] { ExploreFields.CERTAINTY, ExploreFields.BEACON, - ExploreFields.CLASS_NAME }; - String[] concepts = new String[] { "pineapple slices", "ham" }; - NearTextMoveParameters moveTo = gql.arguments() - .nearTextMoveParameterBuilder() - .concepts(new String[] { "Pizza" }) - .force(0.3f) - .build(); - NearTextMoveParameters moveAwayFrom = gql.arguments() - .nearTextMoveParameterBuilder() - .concepts(new String[] { "toast", "bread" }) - .force(0.4f) - .build(); - NearTextArgument withNearText = gql.arguments() - .nearTextArgBuilder() - .concepts(concepts) - .certainty(0.40f) - .moveTo(moveTo) - .moveAwayFrom(moveAwayFrom) - .build(); - - Result result = doExplore(explore -> explore.withFields(fields) - .withNearText(withNearText)); - - List got = extractQueryResult(result, "Explore"); - assertEquals(6, got.size()); - } - - /** - * @see https://github.com/weaviate/java-client/pull/456#issuecomment-3270249876 - */ - @Ignore("Regression in Explorer API in v1.33") - @Test - public void testGraphQLExploreWithDistance() { - ExploreFields[] fields = new ExploreFields[] { ExploreFields.CERTAINTY, ExploreFields.BEACON, - ExploreFields.CLASS_NAME }; - String[] concepts = new String[] { "pineapple slices", "ham" }; - NearTextMoveParameters moveTo = gql.arguments() - .nearTextMoveParameterBuilder() - .concepts(new String[] { "Pizza" }) - .force(0.3f) - .build(); - NearTextMoveParameters moveAwayFrom = gql.arguments() - .nearTextMoveParameterBuilder() - .concepts(new String[] { "toast", "bread" }) - .force(0.4f) - .build(); - NearTextArgument withNearText = gql.arguments() - .nearTextArgBuilder() - .concepts(concepts) - .distance(0.80f) - .moveTo(moveTo) - .moveAwayFrom(moveAwayFrom) - .build(); - - Result result = doExplore(explore -> explore.withFields(fields) - .withNearText(withNearText)); - - List got = extractQueryResult(result, "Explore"); - assertEquals(6, got.size()); - } - - @Test - public void testGraphQLAggregate() { - Result result = doAggregate(aggregate -> aggregate.withFields(meta("count")) - .withClassName("Pizza")); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithWhereFilter() { - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder() - .className("Pizza") - .id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }) - .build(); - - // Insert additional test data - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(pizzaWithID) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 1); - - Result result = doAggregate(aggregate -> aggregate.withFields(meta("count")) - .withClassName("Pizza") - .withWhere(whereText("id", Operator.Equal, newObjID))); - - assertAggregateMetaCount(result, "Pizza", 1, 1.0d); - } - - @Test - public void testGraphQLAggregateWithGroupedByAndWhere() { - // given - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder() - .className("Pizza") - .id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }) - .build(); - - // Insert additional test objects - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(pizzaWithID) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 1); - - Result result = doAggregate(aggregate -> aggregate.withFields(meta("count")) - .withClassName("Pizza") - .withGroupBy("name") - .withWhere(whereText("id", Operator.Equal, newObjID))); - - assertAggregateMetaCount(result, "Pizza", 1, 1.0d); - } - - @Test - public void testGraphQLAggregateWithGroupedBy() { - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder() - .className("Pizza") - .id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }) - .build(); - - // Insert additional test data - Result insert = syncClient.batch() - .objectsBatcher() - .withObjects(pizzaWithID) - .run(); - assumeTrue("all test objects inserted successfully", insert.getResult().length == 1); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withGroupBy("name")); - - assertAggregateMetaCount(result, "Pizza", 5, 1.0d); - } - - @Test - public void testGraphQLAggregateWithNearVector() { - Result getVector = doGet(get -> get.withClassName("Pizza") - .withFields(_additional("vector"))); - Float[] vector = extractVector(getVector, "Get", "Pizza"); - NearVectorArgument nearVector = NearVectorArgument.builder() - .certainty(0.7f) - .vector(vector) - .build(); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearVector(nearVector)); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearObjectAndCertainty() { - Result getId = doGet(get -> get.withClassName("Pizza") - .withFields(_additional("id"))); - String id = extractAdditional(getId, "Get", "Pizza", "id"); - - // when - NearObjectArgument nearObject = NearObjectArgument.builder() - .certainty(0.7f) - .id(id) - .build(); - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearObject(nearObject)); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearObjectAndDistance() { - Result getId = doGet(get -> get.withClassName("Pizza") - .withFields(_additional("id"))); - String id = extractAdditional(getId, "Get", "Pizza", "id"); - - NearObjectArgument nearObject = NearObjectArgument.builder() - .distance(0.3f) - .id(id) - .build(); - Result result = doAggregate(aggregate -> aggregate.withFields(meta("count")) - .withClassName("Pizza") - .withNearObject(nearObject)); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearTextAndCertainty() { - NearTextArgument nearText = NearTextArgument.builder() - .certainty(0.7f) - .concepts(new String[] { "pizza" }) - .build(); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearText(nearText)); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearTextAndDistance() { - NearTextArgument nearText = NearTextArgument.builder() - .distance(0.6f) - .concepts(new String[] { "pizza" }) - .build(); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearText(nearText)); - - assertAggregateMetaCount(result, "Pizza", 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithObjectLimitAndCertainty() { - int limit = 1; - NearTextArgument nearText = NearTextArgument.builder() - .certainty(0.7f) - .concepts(new String[] { "pizza" }) - .build(); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearText(nearText) - .withObjectLimit(limit)); - - assertAggregateMetaCount(result, "Pizza", 1, (double) limit); - } - - @Test - public void testGraphQLAggregateWithObjectLimitAndDistance() { - int limit = 1; - NearTextArgument nearText = NearTextArgument.builder() - .distance(0.3f) - .concepts(new String[] { "pizza" }) - .build(); - - Result result = doAggregate(aggregate -> aggregate.withClassName("Pizza") - .withFields(meta("count")) - .withNearText(nearText) - .withObjectLimit(limit)); - - assertAggregateMetaCount(result, "Pizza", 1, (double) limit); - } - - @Test - public void testGraphQLGetWithGroup() { - GroupArgument group = gql.arguments() - .groupArgBuilder() - .type(GroupType.merge) - .force(1.0f) - .build(); - - Result result = doGet(get -> get.withClassName("Soup") - .withFields(field("name")) - .withGroup(group) - .withLimit(7)); - - List soups = extractClass(result, "Get", "Soup"); - assertEquals(1, soups.size(), "wrong number of soups"); - } - - @Test - public void testGraphQLGetWithSort() { - SortArgument byNameDesc = sort(SortOrder.desc, "name"); - String[] expectedByNameDesc = new String[] { "Quattro Formaggi", "Hawaii", "Frutti di Mare", "Doener" }; - - SortArgument byPriceAsc = sort(SortOrder.asc, "price"); - String[] expectedByPriceAsc = new String[] { "Hawaii", "Doener", "Quattro Formaggi", "Frutti di Mare" }; - - Field name = field("name"); - - Result resultByNameDesc = doGet(get -> get.withClassName("Pizza") - .withSort(byNameDesc) - .withFields(name)); - Result resultByDescriptionAsc = doGet(get -> get.withClassName("Pizza") - .withSort(byPriceAsc) - .withFields(name)); - Result resultByNameDescByPriceAsc = doGet(get -> get.withClassName("Pizza") - .withSort(byNameDesc, byPriceAsc) - .withFields(name)); - - assertObjectNamesEqual(resultByNameDesc, "Get", "Pizza", expectedByNameDesc); - assertObjectNamesEqual(resultByDescriptionAsc, "Get", "Pizza", expectedByPriceAsc); - assertObjectNamesEqual(resultByNameDescByPriceAsc, "Get", "Pizza", expectedByNameDesc); - } - - @Test - public void testGraphQLGetWithTimestampFilters() { - Field additional = _additional("id", "creationTimeUnix", "lastUpdateTimeUnix"); - Result expected = doGet(get -> get.withClassName("Pizza") - .withFields(additional)); - - String expectedCreateTime = extractAdditional(expected, "Get", "Pizza", "creationTimeUnix"); - String expectedUpdateTime = extractAdditional(expected, "Get", "Pizza", "lastUpdateTimeUnix"); - - Result createTimeResult = doGet(get -> get.withClassName("Pizza") - .withWhere(whereText("_creationTimeUnix", Operator.Equal, expectedCreateTime)) - .withFields(additional)); - Result updateTimeResult = doGet(get -> get.withClassName("Pizza") - .withWhere(whereText("_lastUpdateTimeUnix", Operator.Equal, expectedCreateTime)) - .withFields(additional)); - - String resultCreateTime = extractAdditional(createTimeResult, "Get", "Pizza", "creationTimeUnix"); - assertEquals(expectedCreateTime, resultCreateTime); - - String resultUpdateTime = extractAdditional(updateTimeResult, "Get", "Pizza", "lastUpdateTimeUnix"); - assertEquals(expectedUpdateTime, resultUpdateTime); - } - - @Test - public void testGraphQLGetUsingCursorAPI() { - Result result = doGet(get -> get.withClassName("Pizza") - .withAfter("00000000-0000-0000-0000-000000000000") - .withLimit(10) - .withFields(field("name"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(3, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetUsingLimitAndOffset() { - Result result = doGet(get -> get.withClassName("Pizza") - .withOffset(3) - .withLimit(4) - .withFields(field("name"))); - - List pizzas = extractClass(result, "Get", "Pizza"); - assertEquals(1, pizzas.size(), "wrong number of pizzas"); - } - - @Test - public void testGraphQLGetWithGroupBy() { - Field[] hits = new Field[] { Field.builder() - .name("ofDocument") - .fields(new Field[] { Field.builder() - .name("... on Document") - .fields(new Field[] { Field.builder() - .name("_additional{id}").build() }) - .build() - }).build(), Field.builder() - .name("_additional{id distance}").build(), - }; - - Field group = Field.builder() - .name("group") - .fields(new Field[] { Field.builder() - .name("id").build(), - Field.builder() - .name("groupedBy") - .fields(new Field[] { Field.builder() - .name("value").build(), - Field.builder() - .name("path").build(), - }).build(), - Field.builder() - .name("count").build(), - Field.builder() - .name("maxDistance").build(), - Field.builder() - .name("minDistance").build(), - Field.builder() - .name("hits") - .fields(hits).build(), - }) - .build(); - - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { group }) - .build(); - Field ofDocument = Field.builder() - .name("ofDocument{__typename}") - .build(); // Property that we group by - - GroupByArgument groupBy = client.graphQL() - .arguments() - .groupByArgBuilder() - .path(new String[] { "ofDocument" }) - .groups(3) - .objectsPerGroup(10) - .build(); - NearObjectArgument nearObject = client.graphQL() - .arguments() - .nearObjectArgBuilder() - .id("00000000-0000-0000-0000-000000000001") - .build(); - - passageSchema.createAndInsertData(syncClient); - - try { - Result result = doGet(get -> get.withClassName(passageSchema.PASSAGE) - .withNearObject(nearObject) - .withGroupBy(groupBy) - .withFields(ofDocument, _additional)); - - List> passages = extractClass(result, "Get", passageSchema.PASSAGE); - assertEquals(3, passages.size(), "wrong number of passages"); - - // This part of assertions is almost verbatim from package - // io.weaviate.integration.client.graphql.ClientGraphQLTest - // because it involves a lot of inner classes that we don't won't to redefine - // here. - List groups = getGroups(passages); - Assertions.assertThat(groups) - .isNotNull() - .hasSize(3); - for (int i = 0; i < 3; i++) { - Assertions.assertThat(groups.get(i).minDistance) - .isEqualTo(groups.get(i) - .getHits() - .get(0) - .get_additional() - .getDistance()); - Assertions.assertThat(groups.get(i).maxDistance) - .isEqualTo(groups.get(i) - .getHits() - .get(groups.get(i) - .getHits() - .size() - 1) - .get_additional() - .getDistance()); - } - checkGroupElements(expectedHitsA, groups.get(0) - .getHits()); - checkGroupElements(expectedHitsB, groups.get(1) - .getHits()); - } finally { - passageSchema.cleanupWeaviate(syncClient); - } - } - - @Test - public void testGraphQLGetWithGroupByWithHybrid() { - Field[] hits = new Field[] { Field.builder() - .name("content").build(), - Field.builder() - .name("_additional{id distance}").build(), - }; - Field group = Field.builder() - .name("group") - .fields(new Field[] { Field.builder() - .name("id").build(), - Field.builder() - .name("groupedBy") - .fields(new Field[] { Field.builder() - .name("value").build(), - Field.builder() - .name("path").build(), - }).build(), - Field.builder() - .name("count").build(), - Field.builder() - .name("maxDistance").build(), - Field.builder() - .name("minDistance").build(), - Field.builder() - .name("hits") - .fields(hits).build(), - }) - .build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { group }) - .build(); - Field content = Field.builder() - .name("content") - .build(); // Property that we group by - GroupByArgument groupBy = client.graphQL() - .arguments() - .groupByArgBuilder() - .path(new String[] { "content" }) - .groups(3) - .objectsPerGroup(10) - .build(); - - NearTextArgument nearText = NearTextArgument.builder() - .concepts(new String[] { "Passage content 2" }) - .build(); - HybridArgument hybrid = HybridArgument.builder() - .searches(HybridArgument.Searches.builder() - .nearText(nearText) - .build()) - .query("Passage content 2") - .alpha(0.9f) - .build(); - - passageSchema.createAndInsertData(syncClient); - - try { - Result groupByResult = doGet(get -> get.withClassName(passageSchema.PASSAGE) - .withHybrid(hybrid) - .withGroupBy(groupBy) - .withFields(content, _additional)); - - List> result = extractClass(groupByResult, "Get", passageSchema.PASSAGE); - Assertions.assertThat(result) - .isNotNull() - .hasSize(3); - List groups = getGroups(result); - Assertions.assertThat(groups) - .isNotNull() - .hasSize(3); - for (int i = 0; i < 3; i++) { - if (i == 0) { - Assertions.assertThat(groups.get(i).groupedBy.value) - .isEqualTo("Passage content 2"); - } - Assertions.assertThat(groups.get(i).minDistance) - .isEqualTo(groups.get(i) - .getHits() - .get(0) - .get_additional() - .getDistance()); - Assertions.assertThat(groups.get(i).maxDistance) - .isEqualTo(groups.get(i) - .getHits() - .get(groups.get(i) - .getHits() - .size() - 1) - .get_additional() - .getDistance()); - } - } finally { - passageSchema.cleanupWeaviate(syncClient); - } - } - - @Test - public void shouldSupportSearchByUUID() { - String className = "ClassUUID"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("class with uuid properties") - .properties(Arrays.asList( - Property.builder() - .dataType(Collections.singletonList(DataType.UUID)) - .name("uuidProp") - .build(), - Property.builder() - .dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .name("uuidArrayProp") - .build())) - .build(); - - String id = "abefd256-8574-442b-9293-9205193737ee"; - Map properties = new HashMap<>(); - properties.put("uuidProp", "7aaa79d3-a564-45db-8fa8-c49e20b8a39a"); - properties.put("uuidArrayProp", - new String[] { "f70512a3-26cb-4ae4-9369-204555917f15", "9e516f40-fd54-4083-a476-f4675b2b5f92" - }); - - Result createStatus = syncClient.schema() - .classCreator() - .withClass(clazz) - .run(); - Assertions.assertThat(createStatus) - .isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result objectStatus = syncClient.data() - .creator() - .withClassName(className) - .withID(id) - .withProperties(properties) - .run(); - Assertions.assertThat(objectStatus) - .isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult) - .isNotNull(); - - Field fieldId = _additional("id"); - WhereArgument whereUuid = whereText("uuidProp", Operator.Equal, "7aaa79d3-a564-45db-8fa8-c49e20b8a39a"); - WhereArgument whereUuidArray1 = whereText("uuidArrayProp", Operator.Equal, "f70512a3-26cb-4ae4-9369-204555917f15"); - WhereArgument whereUuidArray2 = whereText("uuidArrayProp", Operator.Equal, "9e516f40-fd54-4083-a476-f4675b2b5f92"); - - Result resultUuid = doGet(get -> get.withWhere(whereUuid) - .withClassName(className) - .withFields(fieldId)); - Result resultUuidArray1 = doGet(get -> get.withWhere(whereUuidArray1) - .withClassName(className) - .withFields(fieldId)); - Result resultUuidArray2 = doGet(get -> get.withWhere(whereUuidArray2) - .withClassName(className) - .withFields(fieldId)); - - assertIds(className, resultUuid, new String[] { id }); - assertIds(className, resultUuidArray1, new String[] { id }); - assertIds(className, resultUuidArray2, new String[] { id }); - - Result deleteStatus = syncClient.schema() - .allDeleter() - .run(); - Assertions.assertThat(deleteStatus) - .isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - private Result doGet(Consumer build) { - Get get = gql.get(); - build.accept(get); - try { - return get.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.get(): " + e.getMessage()); - return null; - } - } - - private Result doRaw(Consumer build) { - Raw raw = gql.raw(); - build.accept(raw); - try { - return raw.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.raw(): " + e.getMessage()); - return null; - } - } - - private Result doExplore(Consumer build) { - Explore explore = gql.explore(); - build.accept(explore); - try { - return explore.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.explore(): " + e.getMessage()); - return null; - } - } - - private Result doAggregate(Consumer build) { - Aggregate aggregate = gql.aggregate(); - build.accept(aggregate); - try { - return aggregate.run() - .get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.aggregate(): " + e.getMessage()); - return null; - } - } - - private SortArgument sort(SortOrder ord, String... properties) { - return gql.arguments() - .sortArgBuilder() - .path(properties) - .order(ord) - .build(); - } - - private void assertWhereResultSize(int expectedSize, Result result, String className) { - List getClass = extractClass(result, "Get", className); - assertEquals(expectedSize, getClass.size()); - } - - @SuppressWarnings("unchecked") - private T extractAdditional(Result result, String queryType, String className, - String fieldName) { - List objects = extractClass(result, queryType, className); - - Map> firstObject = (Map>) objects.get(0); - Map additional = firstObject.get("_additional"); - - return (T) additional.get(fieldName); - } - - private Float[] extractVector(Result result, String queryType, String className) { - ArrayList vector = extractAdditional(result, queryType, className, "vector"); - Float[] out = new Float[vector.size()]; - for (int i = 0; i < vector.size(); i++) { - out[i] = vector.get(i) - .floatValue(); - } - return out; - } - - @SuppressWarnings("unchecked") - private void assertAggregateMetaCount(Result result, String className, int wantObjects, - Double wantCount) { - List objects = extractClass(result, "Aggregate", className); - - assertEquals(wantObjects, objects.size(), "wrong number of objects"); - Map> firstObject = (Map>) objects.get(0); - Map meta = firstObject.get("meta"); - assertEquals(wantCount, meta.get("count"), "wrong meta:count"); - } - - private void assertObjectNamesEqual(Result result, String queryType, String className, - String[] want) { - List> objects = extractClass(result, queryType, className); - assertEquals(want.length, objects.size()); - for (int i = 0; i < want.length; i++) { - assertEquals(want[i], objects.get(i) - .get("name"), String.format("%s[%d] has wrong name", className.toLowerCase(), i)); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTypedTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTypedTest.java deleted file mode 100644 index 81148a5f0..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/ClientGraphQLTypedTest.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.graphql.ClientGraphQLTypedTestSuite; -import java.util.concurrent.ExecutionException; -import java.util.function.Supplier; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientGraphQLTypedTest { - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics.createTestSchemaAndData(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testGraphQLGet() { - Supplier>> supplyPizza =() -> { - try (WeaviateAsyncClient asyncClient = client.async()) { - return asyncClient.graphQL().get() - .withClassName("Pizza") - .withFields(Field.builder().name("name").build(), Field.builder().name("description").build()) - .run(ClientGraphQLTypedTestSuite.Pizzas.class).get(); - } catch (InterruptedException | ExecutionException e) { - throw new RuntimeException(e); - } - }; - ClientGraphQLTypedTestSuite.testGraphQLGet(supplyPizza); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/graphql/ClusterGraphQLTest.java b/src/test/java/io/weaviate/integration/client/async/graphql/ClusterGraphQLTest.java deleted file mode 100644 index 56d42cb33..000000000 --- a/src/test/java/io/weaviate/integration/client/async/graphql/ClusterGraphQLTest.java +++ /dev/null @@ -1,84 +0,0 @@ -package io.weaviate.integration.client.async.graphql; - -import com.google.gson.internal.LinkedTreeMap; -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.async.graphql.GraphQL; -import io.weaviate.client.v1.async.graphql.api.Get; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.integration.client.WeaviateDockerComposeCluster; -import io.weaviate.integration.client.WeaviateTestGenerics; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.runner.RunWith; - -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; - -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; - -@RunWith(JParamsTestRunner.class) -public class ClusterGraphQLTest extends AbstractAsyncClientTest { - private static final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - private String address; - - private WeaviateClient syncClient; - private WeaviateAsyncClient client; - private GraphQL gql; - - @ClassRule - public static WeaviateDockerComposeCluster compose = new WeaviateDockerComposeCluster(); - - @Before - public void before() { - address = compose.getHttpHost0Address(); - - syncClient = new WeaviateClient(new Config("http", address)); - testGenerics.createReplicatedTestSchemaAndData(syncClient); - - client = syncClient.async(); - gql = client.graphQL(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(syncClient); - client.close(); - } - - public static Object[][] provideConsistencyLevels() { - return new Object[][]{ { ConsistencyLevel.ALL }, { ConsistencyLevel.QUORUM }, { ConsistencyLevel.ONE } }; - } - - @DataMethod(source = ClusterGraphQLTest.class, method = "provideConsistencyLevels") - @Test - public void testGraphQLGetUsingConsistencyLevel(String consistency) { - Result result = doGet(get -> get.withClassName("Pizza").withConsistencyLevel(consistency) - .withFields(field("name"), _additional("isConsistent"))); - - List>> pizzas = extractClass(result, "Get", "Pizza"); - for (LinkedTreeMap> pizza : pizzas) { - assertTrue("not consistent with ConsistencyLevel=" + consistency, pizza.get("_additional").get("isConsistent")); - } - } - - private Result doGet(Consumer build) { - Get get = gql.get(); - build.accept(get); - try { - return get.run().get(); - } catch (InterruptedException | ExecutionException e) { - fail("graphQL.get(): " + e.getMessage()); - return null; - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/groups/ClientGroupsTest.java b/src/test/java/io/weaviate/integration/client/async/groups/ClientGroupsTest.java deleted file mode 100644 index d179fa80a..000000000 --- a/src/test/java/io/weaviate/integration/client/async/groups/ClientGroupsTest.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.integration.client.async.groups; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.groups.Groups; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.integration.client.async.rbac.ClientRbacTest; -import io.weaviate.integration.tests.groups.ClientGroupsTestSuite; - -public class ClientGroupsTest extends ClientRbacTest implements ClientGroupsTestSuite.Oidc { - private final Groups groups; - - public ClientGroupsTest(Config config, String apiKey) { - super(config, apiKey); - try { - this.groups = WeaviateAuthClient.apiKey(config, apiKey).async().groups(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - @Override - public Result> getAssignedRoles(String groupId) { - return rethrow(() -> groups.oidc().assignedRolesGetter().withGroupId(groupId).run()); - } - - @Override - public Result> getKnownGroupNames() { - return rethrow(() -> groups.oidc().knownGroupNamesGetter().run()); - } - - @Override - public Result assignRoles(String groupId, String... roles) { - return rethrow(() -> groups.oidc().roleAssigner().withGroupId(groupId).witRoles(roles).run()); - } - - @Override - public Result revokeRoles(String groupId, String... roles) { - return rethrow(() -> groups.oidc().roleRevoker().withGroupId(groupId).witRoles(roles).run()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/misc/ClientMiscTest.java b/src/test/java/io/weaviate/integration/client/async/misc/ClientMiscTest.java deleted file mode 100644 index fb3bd06c6..000000000 --- a/src/test/java/io/weaviate/integration/client/async/misc/ClientMiscTest.java +++ /dev/null @@ -1,126 +0,0 @@ -package io.weaviate.integration.client.async.misc; - -import io.weaviate.client.Config; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.Meta; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.misc.MiscTestSuite; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import org.apache.hc.core5.concurrent.FutureCallback; -import static org.junit.Assert.assertNull; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientMiscTest { - - private WeaviateClient client; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @Test - public void testMiscLivenessEndpoint() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - // perform operations - Future> future = asyncClient.misc().liveChecker().run(); - Result livenessCheck = future.get(); - // assert results - MiscTestSuite.assertLivenessOrReadiness(livenessCheck); - } - } - - @Test - public void testMiscLivenessEndpointWithCallback() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - // perform operations - FutureCallback> callback = new FutureCallback>() { - - @Override - public void completed(Result booleanResult) { - MiscTestSuite.assertLivenessOrReadiness(booleanResult); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - } - }; - Future> future = asyncClient.misc().liveChecker().run(callback); - future.get(); - } - } - - @Test - public void testMiscReadinessEndpoint() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - // perform operations - Future> future = asyncClient.misc().readyChecker().run(); - Result readinessCheck = future.get(); - // assert results - MiscTestSuite.assertLivenessOrReadiness(readinessCheck); - } - } - - @Test - public void testMiscReadinessEndpointWithCallback() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - // perform operations - FutureCallback> callback = new FutureCallback>() { - - @Override - public void completed(Result booleanResult) { - MiscTestSuite.assertLivenessOrReadiness(booleanResult); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - } - }; - Future> future = asyncClient.misc().readyChecker().run(callback); - future.get(); - } - } - - @Test - public void testMiscMetaEndpointWithCallback() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient asyncClient = client.async()) { - // perform operations - FutureCallback> callback = new FutureCallback>() { - @Override - public void completed(Result result) { - MiscTestSuite.assertMeta(result); - } - - @Override - public void failed(Exception ex) { - assertNull(ex); - } - - @Override - public void cancelled() { - } - }; - Future> future = asyncClient.misc().metaGetter().run(callback); - future.get(); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/rbac/ClientRbacTest.java b/src/test/java/io/weaviate/integration/client/async/rbac/ClientRbacTest.java deleted file mode 100644 index 46deafae6..000000000 --- a/src/test/java/io/weaviate/integration/client/async/rbac/ClientRbacTest.java +++ /dev/null @@ -1,104 +0,0 @@ -package io.weaviate.integration.client.async.rbac; - -import java.util.List; -import java.util.concurrent.Callable; -import java.util.concurrent.Future; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.rbac.Roles; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.rbac.model.GroupAssignment; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.rbac.model.UserAssignment; -import io.weaviate.integration.tests.rbac.ClientRbacTestSuite; -import io.weaviate.integration.tests.users.ClientUsersTestSuite; - -/** - * ClientRbacTest is a {@link ClientRbacTestSuite.Rbac} implementation and a - * wrapper around WeaviateAsyncClient.Roles client which allows the latter to - * be used in the ClientRbacTestSuite. - */ -public class ClientRbacTest implements ClientRbacTestSuite.Rbac { - private Roles roles; - - public ClientRbacTest(Config config, String apiKey) { - try { - this.roles = WeaviateAuthClient.apiKey(config, apiKey).async().roles(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - /** - * Get Future result and rethrow any exception as a RuntimeException - * to allow calling AsyncClient methods without clashing with - * {@link ClientRbacTestSuite.Rbac} and {@link ClientUsersTestSuite.Users} - * method signatures. - */ - protected T rethrow(Callable> c) { - try { - return c.call().get(); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @Override - public Result getRole(String role) { - return rethrow(() -> roles.getter().withName(role).run()); - } - - @Override - public Result> getAll() { - return rethrow(() -> roles.allGetter().run()); - } - - @Override - public Result> getAssignedUsers(String role) { - return rethrow(() -> roles.assignedUsersGetter().withRole(role).run()); - } - - @Override - public Result createRole(String role, Permission... permissions) { - return rethrow(() -> roles.creator().withName(role).withPermissions(permissions).run()); - } - - @Override - public void deleteRole(String role) { - rethrow(() -> roles.deleter().withName(role).run()); - } - - @Override - public Result hasPermission(String role, Permission perm) { - return rethrow(() -> roles.permissionChecker().withRole(role).withPermission(perm).run()); - } - - @Override - public Result exists(String role) { - return rethrow(() -> roles.exists().withName(role).run()); - } - - @Override - public Result addPermissions(String role, Permission... permissions) { - return rethrow(() -> roles.permissionAdder().withRole(role).withPermissions(permissions).run()); - } - - @Override - public Result removePermissions(String role, Permission... permissions) { - return rethrow(() -> roles.permissionRemover().withRole(role).withPermissions(permissions).run()); - } - - @Override - public Result> getUserAssignments(String role) { - return rethrow(() -> roles.userAssignmentsGetter().withRole(role).run()); - } - - @Override - - public Result> getGroupAssignments(String role) { - return rethrow(() -> roles.groupAssignmentsGetter().withRole(role).run()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaMultiTenancyTest.java deleted file mode 100644 index c3ed622c3..000000000 --- a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaMultiTenancyTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package io.weaviate.integration.client.async.schema; - -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_1; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_2; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.LIST; - -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.ExecutionException; - -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.schema.model.ActivityStatus; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; - -public class ClientSchemaMultiTenancyTest { - private WeaviateClient syncClient; - private WeaviateTestGenerics testGenerics; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - syncClient = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - testGenerics.createSchemaPizzaForTenants(syncClient); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(syncClient); - } - - @Test - public void shouldGetTenantsFromMTClass() throws ExecutionException, InterruptedException { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createTenantsPizza(syncClient, tenants); - - try (WeaviateAsyncClient client = syncClient.async()) { - Result> getResult = client.schema().tenantsGetter() - .withClassName("Pizza") - .run().get(); - - assertThat(getResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(LIST) - .hasSize(tenants.length); - - String[] fetchedTenants = getResult.getResult().stream() - .map(Tenant::getName) - .toArray(String[]::new); - assertThat(fetchedTenants).containsExactlyInAnyOrder(tenantNames); - } - } - - @Test - public void shouldAddTenantsToMTClass() throws ExecutionException, InterruptedException { - String[] tenants = new String[]{"TenantNo1", "TenantNo2"}; - - Tenant[] tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).build()) - .toArray(Tenant[]::new); - - try (WeaviateAsyncClient client = syncClient.async()) { - Result addResult = client.schema().tenantsCreator() - .withClassName("Pizza") - .withTenants(tenantObjs) - .run().get(); - - assertThat(addResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - for (String tenant: tenants) { - Result exists = client.schema().tenantsExists() - .withClassName("Pizza") - .withTenant(tenant) - .run().get(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - } - } - - @Test - public void shouldUpdateTenantsOfMTClass() throws ExecutionException, InterruptedException { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - testGenerics.createTenantsPizza(syncClient, tenants); - - try (WeaviateAsyncClient client = syncClient.async()) { - Result updateResult = client.schema().tenantsUpdater() - .withClassName("Pizza") - .withTenants(Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant.getName()).activityStatus(ActivityStatus.COLD).build()) - .toArray(Tenant[]::new)) - .run().get(); - - assertThat(updateResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - } - - - @Test - public void shouldDeleteTenantsFromMTClass() throws ExecutionException, InterruptedException { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - testGenerics.createTenantsPizza(syncClient, tenants); - - try (WeaviateAsyncClient client = syncClient.async()) { - Result deleteResult = client.schema().tenantsDeleter() - .withClassName("Pizza") - .withTenants(TENANT_1.getName(), TENANT_2.getName(), "nonExistentTenant") - .run().get(); - - assertThat(deleteResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java b/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java deleted file mode 100644 index 96cbb9613..000000000 --- a/src/test/java/io/weaviate/integration/client/async/schema/ClientSchemaTest.java +++ /dev/null @@ -1,714 +0,0 @@ -package io.weaviate.integration.client.async.schema; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.MAP; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.assertFalse; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.concurrent.atomic.AtomicBoolean; - -import org.apache.hc.core5.concurrent.FutureCallback; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.async.WeaviateAsyncClient; -import io.weaviate.client.v1.misc.model.PQConfig; -import io.weaviate.client.v1.misc.model.ReplicationConfig; -import io.weaviate.client.v1.misc.model.ShardingConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.Shard; -import io.weaviate.client.v1.schema.model.ShardStatus; -import io.weaviate.client.v1.schema.model.ShardStatuses; -import io.weaviate.client.v1.schema.model.Tokenization; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.client.v1.schema.model.WeaviateClass.VectorConfig; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.schema.SchemaTestSuite; - -public class ClientSchemaTest { - private WeaviateClient syncClient; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - syncClient = new WeaviateClient(config); - } - - @After - public void after() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - client.schema().allDeleter().run(new FutureCallback>() { - @Override - public void completed(Result deleted) { - assertThat(deleted.hasErrors()).isFalse(); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } - }).get(); - } - } - - @Test - public void testSchemaCreateBandClass() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = SchemaTestSuite.testSchemaCreateBandClass.clazz; - // when - Future> createStatusFuture = client.schema().classCreator().withClass(clazz).run(); - Result createStatus = createStatusFuture.get(); - Future> schemaFuture = client.schema().getter().run(); - Result schema = schemaFuture.get(); - - // then - SchemaTestSuite.testSchemaCreateBandClass.assertResults(createStatus, schema); - } - } - - @Test - public void testSchemaCreateRunClass() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = SchemaTestSuite.testSchemaCreateRunClass.clazz; - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - // then - SchemaTestSuite.testSchemaCreateRunClass.assertResults(createStatus, schemaAfterCreate, - deleteStatus, schemaAfterDelete); - } - } - - @Test - public void testSchemaDeleteClasses() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaDeleteClasses.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteClasses.chickenSoup; - // when - client.schema().classCreator().withClass(pizza).run(new FutureCallback>() { - @Override - public void completed(Result pizzaCreateStatus) { - assertNotNull(pizzaCreateStatus); - assertTrue(pizzaCreateStatus.getResult()); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - } - }).get(); - client.schema().classCreator().withClass(chickenSoup) - .run(new FutureCallback>() { - @Override - public void completed(Result chickenSoupCreateStatus) { - assertNotNull(chickenSoupCreateStatus); - assertTrue(chickenSoupCreateStatus.getResult()); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } - }).get(); - client.schema().getter().run(new FutureCallback>() { - @Override - public void completed(Result schemaAfterCreate) { - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(2, schemaAfterCreate.getResult().getClasses().size()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().stream() - .filter(o -> o.getClassName().equals(pizza.getClassName())).count()); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } - }).get(); - - client.schema().allDeleter().run(new FutureCallback>() { - @Override - public void completed(Result result) { - assertNotNull(result); - assertTrue(result.getResult()); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } - }).get(); - - client.schema().getter().run(new FutureCallback>() { - @Override - public void completed(Result schemaResult) { - assertNotNull(schemaResult); - assertNotNull(schemaResult.getResult()); - assertThat(schemaResult.getResult().getClasses()).isNullOrEmpty(); - } - - @Override - public void failed(Exception e) { - assertNull(e); - } - - @Override - public void cancelled() { - - } - }).get(); - } - } - - @Test - public void testSchemaDeleteAllSchema() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaDeleteAllSchema.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteAllSchema.chickenSoup; - // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run().get(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteAllStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - // then - SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); - } - } - - @Test - public void testSchemaCreateClassesAddProperties() - throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaCreateClassesAddProperties.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaCreateClassesAddProperties.chickenSoup; - Property newProperty = SchemaTestSuite.testSchemaCreateClassesAddProperties.newProperty; - // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run().get(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run().get(); - Result pizzaPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(pizza.getClassName()).run().get(); - Result chickenSoupPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteAllStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - - // then - SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, pizzaPropertyCreateStatus, chickenSoupPropertyCreateStatus, - schemaAfterCreate, deleteAllStatus, schemaAfterDelete); - } - } - - @Test - public void testSchemaAddVectors() throws ExecutionException, InterruptedException { - // Arrange - VectorConfig vector = VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(Collections.singletonMap("none", Collections.emptyMap())) - .vectorIndexConfig(VectorIndexConfig.builder().build()) - .build(); - String className = "Pizza_testSchemaAddVectors"; - try (WeaviateAsyncClient client = syncClient.async()) { - client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(className) - .properties(Collections.singletonList( - Property.builder() - .name("title").dataType(Collections.singletonList(DataType.TEXT)) - .build())) - .vectorConfig(Collections.singletonMap("default", vector)) - .build()) - .run().get(); - - // Act - AtomicBoolean completed = new AtomicBoolean(false); - FutureCallback> callback = new FutureCallback>() { - - @Override - public void completed(Result result) { - completed.set(true); - } - - @Override - public void failed(Exception ex) { - completed.set(true); - } - - @Override - public void cancelled() { - } - }; - Result add = client.schema().vectorAdder() - .withClassName(className) - .withVectorConfig("vector-a", vector) - .withVectorConfig("vector-b", vector) - .run(callback).get(); - assertNull("error adding new vectors", add.getError()); - - Result result = client.schema().classGetter() - .withClassName(className).run().get(); - WeaviateClass pizza = result.getResult(); - assertThat(pizza.getVectorConfig()) - .as("has all 3 vectors") - .containsKeys("default", "vector-a", "vector-b"); - assertTrue("callback called on completion", completed.get()); - } - } - - @Test - public void testSchemaCreateClassExplicitVectorizerWithProperties() - throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - Map text2vecContextionary = new HashMap<>(); - text2vecContextionary.put("vectorizeClassName", false); - Map moduleConfig = new HashMap<>(); - moduleConfig.put("text2vec-contextionary", text2vecContextionary); - - WeaviateClass clazz = WeaviateClass.builder().className("Article") - .description("A written text, for example a news article or blog post") - .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").moduleConfig(moduleConfig) - .properties(new ArrayList() { - { - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("Title of the article").name("title").tokenization(Tokenization.FIELD) - .build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("The content of the article").name("content") - .tokenization(Tokenization.WORD).build()); - } - }).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - - // then - assertResultTrue(createStatus); - assertClassesSize(1, schemaAfterCreate); - - WeaviateClass resultArticleClass = schemaAfterCreate.getResult().getClasses().get(0); - assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArticleClass); - - assertThat(resultArticleClass.getModuleConfig()).asInstanceOf(MAP) - .containsOnlyKeys("text2vec-contextionary") - .extracting(m -> m.get("text2vec-contextionary")).asInstanceOf(MAP) - .containsOnlyKeys("vectorizeClassName").extracting(m -> m.get("vectorizeClassName")) - .isEqualTo(false); - - assertPropertiesSize(2, resultArticleClass); - assertPropertyEquals("title", "field", resultArticleClass.getProperties().get(0)); - assertPropertyEquals("content", "word", resultArticleClass.getProperties().get(1)); - - assertResultTrue(deleteStatus); - assertClassesSize(0, schemaAfterDelete); - } - } - - @Test - public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() - throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = WeaviateClass.builder().className("ClassArrays") - .description("Class which properties are all array properties").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").properties(new ArrayList() { - { - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT_ARRAY); - } - }).name("stringArray").tokenization(Tokenization.FIELD).build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT_ARRAY); - } - }).name("textArray").tokenization(Tokenization.WORD).build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.INT_ARRAY); - } - }).name("intArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.NUMBER_ARRAY); - } - }).name("numberArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.BOOLEAN_ARRAY); - } - }).name("booleanArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.DATE_ARRAY); - } - }).name("dateArray").build()); - } - }).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - - // then - assertResultTrue(createStatus); - assertClassesSize(1, schemaAfterCreate); - - WeaviateClass resultArraysClass = schemaAfterCreate.getResult().getClasses().get(0); - assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArraysClass); - assertPropertiesSize(6, resultArraysClass); - assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", - resultArraysClass.getProperties().get(0)); - assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", - resultArraysClass.getProperties().get(1)); - assertPropertyEquals("intArray", DataType.INT_ARRAY, null, - resultArraysClass.getProperties().get(2)); - assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, - resultArraysClass.getProperties().get(3)); - assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, - resultArraysClass.getProperties().get(4)); - assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, - resultArraysClass.getProperties().get(5)); - - assertResultTrue(deleteStatus); - assertClassesSize(0, schemaAfterDelete); - } - } - - @Test - public void testSchemaCreateClassWithProperties() - throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Article") - .description("A written text, for example a news article or blog post") - .properties(new ArrayList() { - { - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("Title of the article").name("title").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("The content of the article").name("content").build()); - } - }).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result schemaAfterCreate = client.schema().getter().run().get(); - Result deleteStatus = client.schema().allDeleter().run().get(); - Result schemaAfterDelete = client.schema().getter().run().get(); - - // then - assertResultTrue(createStatus); - assertClassesSize(1, schemaAfterCreate); - - WeaviateClass resultArticleClass = schemaAfterCreate.getResult().getClasses().get(0); - assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArticleClass); - assertPropertiesSize(2, resultArticleClass); - assertPropertyEquals("title", "word", resultArticleClass.getProperties().get(0)); - assertPropertyEquals("content", "word", resultArticleClass.getProperties().get(1)); - - assertResultTrue(deleteStatus); - assertClassesSize(0, schemaAfterDelete); - } - } - - @Test - public void testSchemaCreateClassWithInvalidTokenizationProperty() - throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass pizza = WeaviateClass.builder().className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - - Property notExistingTokenization = Property.builder().dataType(Collections.singletonList(DataType.TEXT)) - .description("someString").name("someString").tokenization("not-existing").build(); - Property notSupportedTokenizationForInt = Property.builder().dataType(Collections.singletonList(DataType.INT)) - .description("someInt").name("someInt").tokenization(Tokenization.WORD).build(); - // when - Result createStatus = client.schema().classCreator().withClass(pizza).run().get(); - Result notExistingTokenizationCreateStatus = client.schema().propertyCreator() - .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run().get(); - Result notSupportedTokenizationForIntCreateStatus = client.schema().propertyCreator() - .withProperty(notSupportedTokenizationForInt) - .withClassName(pizza.getClassName()).run().get(); - - // then - assertResultTrue(createStatus); - - assertResultError( - "tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", - notExistingTokenizationCreateStatus); - assertResultError("tokenization is not allowed for data type 'int'", - notSupportedTokenizationForIntCreateStatus); - } - } - - @Test - public void testSchemaGetBandClass() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run().get(); - Result nonExistentClass = client.schema().classGetter().withClassName("nonExistentClass").run() - .get(); - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertEquals(clazz.getClassName(), bandClass.getResult().getClassName()); - assertEquals(clazz.getDescription(), bandClass.getResult().getDescription()); - assertEquals(clazz.getVectorIndexType(), bandClass.getResult().getVectorIndexType()); - assertEquals(clazz.getVectorizer(), bandClass.getResult().getVectorizer()); - assertNotNull(nonExistentClass); - assertNull(nonExistentClass.getError()); - assertNull(nonExistentClass.getResult()); - } - } - - @Test - public void testSchemaGetShards() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - Result bandClassExists = client.schema().exists().withClassName(clazz.getClassName()).run().get(); - Result nonExistentClassExists = client.schema().exists().withClassName("nonExistentClass").run().get(); - // then - assertResultTrue(createStatus); - assertResultTrue(bandClassExists); - assertNotNull(nonExistentClassExists); - assertFalse(nonExistentClassExists.getResult()); - assertNull(nonExistentClassExists.getError()); - Result shards = client.schema().shardsGetter().withClassName(clazz.getClassName()).run().get(); - assertNotNull(shards); - assertNotNull(shards.getResult()); - assertEquals(1, shards.getResult().length); - Shard shard = shards.getResult()[0]; - assertNotNull(shard.getName()); - assertNotNull(shard.getStatus()); - } - } - - @Test - public void shouldUpdateClass() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - String className = "Question"; - List properties = Arrays.asList( - Property.builder().name("question").dataType(Arrays.asList(DataType.TEXT)).build(), - Property.builder().name("answer").dataType(Arrays.asList(DataType.TEXT)).build()); - - WeaviateClass jeopardyClass = WeaviateClass.builder().className(className).description("A Jeopardy! question") - .vectorizer("text2vec-contextionary").properties(properties).build(); - - Result createResult = client.schema().classCreator().withClass(jeopardyClass).run().get(); - - assertThat(createResult).isNotNull().withFailMessage(() -> createResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); - - Result createdClassResult = client.schema().classGetter().withClassName(className).run().get(); - - assertThat(createdClassResult).isNotNull() - .withFailMessage(() -> createdClassResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) - .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .extracting(VectorIndexConfig::getPq).isNotNull().returns(false, PQConfig::getEnabled); - - WeaviateClass newJeopardyClass = WeaviateClass.builder().className(className) - .vectorizer("text2vec-contextionary").properties(properties) - .vectorIndexConfig( - VectorIndexConfig.builder().filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) - .pq(PQConfig.builder().enabled(true).trainingLimit(99_999).segments(96).build()) - .build()) - .replicationConfig(ReplicationConfig.builder() - .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT).build()) - .build(); - - Result updateResult = client.schema().classUpdater().withClass(newJeopardyClass).run().get(); - - assertThat(updateResult).isNotNull().withFailMessage(() -> updateResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); - - Result updatedClassResult = client.schema().classGetter().withClassName(className).run().get(); - - assertThat(updatedClassResult).isNotNull() - .withFailMessage(() -> updatedClassResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) - .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) - .extracting(VectorIndexConfig::getPq).isNotNull().returns(true, PQConfig::getEnabled) - .returns(96, PQConfig::getSegments).returns(99_999, PQConfig::getTrainingLimit); - - assertThat(updatedClassResult.getResult()).extracting(WeaviateClass::getReplicationConfig) - .isNotNull().returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, - ReplicationConfig::getDeletionStrategy); - } - } - - @Test - public void testSchemaUpdateShards() throws ExecutionException, InterruptedException { - try (WeaviateAsyncClient client = syncClient.async()) { - // given - String className = "Band"; - int shardCount = 3; - ShardingConfig shardingConfig = ShardingConfig.builder().actualCount(shardCount) - .actualVirtualCount(128).desiredCount(shardCount).desiredVirtualCount(128) - .function("murmur3").key("_id").strategy("hash").virtualPerPhysical(128).build(); - WeaviateClass clazz = WeaviateClass.builder().className(className) - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").shardingConfig(shardingConfig).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run().get(); - assertResultTrue(createStatus); - // then - Result shards = client.schema().shardsGetter().withClassName(className).run().get(); - assertNotNull(shards); - assertNull(shards.getError()); - assertNotNull(shards.getResult()); - assertEquals(3, shards.getResult().length); - // update shard status to READONLY - Result updateToREADONLY = client.schema().shardsUpdater() - .withClassName(className).withStatus(ShardStatuses.READONLY).run().get(); - assertNotNull(updateToREADONLY.getResult()); - assertEquals(3, updateToREADONLY.getResult().length); - for (ShardStatus s : updateToREADONLY.getResult()) { - assertEquals(ShardStatuses.READONLY, s.getStatus()); - } - // update shard status to READY - Result updateToREADY = client.schema().shardsUpdater().withClassName(className) - .withStatus(ShardStatuses.READY).run().get(); - assertNotNull(updateToREADY.getResult()); - assertEquals(3, updateToREADY.getResult().length); - for (ShardStatus s : updateToREADY.getResult()) { - assertEquals(ShardStatuses.READY, s.getStatus()); - } - } - } - - private void assertResultTrue(Result result) { - assertNotNull(result); - assertTrue(result.getResult()); - } - - private void assertClassesSize(int expectedSize, Result schemaAfterCreate) { - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(expectedSize, schemaAfterCreate.getResult().getClasses().size()); - } - - private void assertClassEquals(String expectedName, String expectedDescription, - WeaviateClass schemaClass) { - assertEquals(expectedName, schemaClass.getClassName()); - assertEquals(expectedDescription, schemaClass.getDescription()); - } - - private void assertPropertiesSize(int expectedSize, WeaviateClass schemaClass) { - assertNotNull(schemaClass.getProperties()); - assertEquals(expectedSize, schemaClass.getProperties().size()); - } - - private void assertPropertyEquals(String expectedName, String expectedTokenization, - Property property) { - assertEquals(expectedName, property.getName()); - assertEquals(expectedTokenization, property.getTokenization()); - } - - private void assertPropertyEquals(String expectedName, String expectedDataType, - String expectedTokenization, Property property) { - assertPropertyEquals(expectedName, expectedTokenization, property); - assertTrue(property.getDataType().size() > 0); - assertEquals(expectedDataType, property.getDataType().get(0)); - } - - private void assertResultError(String msg, Result result) { - assertNotNull(result); - assertTrue(result.hasErrors()); - List messages = result.getError().getMessages(); - assertEquals(1, messages.size()); - assertEquals(msg, messages.get(0).getMessage()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/async/users/ClientUsersTest.java b/src/test/java/io/weaviate/integration/client/async/users/ClientUsersTest.java deleted file mode 100644 index 792d7f5e0..000000000 --- a/src/test/java/io/weaviate/integration/client/async/users/ClientUsersTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package io.weaviate.integration.client.async.users; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.async.users.DbUsers; -import io.weaviate.client.v1.async.users.OidcUsers; -import io.weaviate.client.v1.async.users.Users; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.users.model.User; -import io.weaviate.client.v1.users.model.UserDb; -import io.weaviate.integration.client.async.rbac.ClientRbacTest; -import io.weaviate.integration.tests.users.ClientUsersTestSuite; - -/** - * ClientUsersTest is a {@link ClientUsersTestSuite.Users} implementation and a - * wrapper around WeaviateAsyncClient.Roles client which allows the latter to be - * used in the ClientUsersTestSuite. - */ -public class ClientUsersTest extends ClientRbacTest implements ClientUsersTestSuite.Users { - private Users users; - - public ClientUsersTest(Config config, String apiKey) { - super(config, apiKey); - try { - this.users = WeaviateAuthClient.apiKey(config, apiKey).async().users(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - @Override - public Result getMyUser() { - return rethrow(() -> users.myUserGetter().run()); - } - - @Override - public Result> getUserRoles(String user) { - return rethrow(() -> users.userRolesGetter().withUserId(user).run()); - } - - @Override - public Result assignRoles(String user, String... roles) { - return rethrow(() -> this.users.assigner().withUserId(user).witRoles(roles).run()); - } - - @Override - public Result revokeRoles(String user, String... roles) { - return rethrow(() -> this.users.revoker().withUserId(user).witRoles(roles).run()); - } - - @Override - public ClientUsersTestSuite.DbUsers db() { - return new NamespacedUsers(false); - } - - @Override - public ClientUsersTestSuite.OidcUsers oidc() { - return new NamespacedUsers(true); - } - - /** - * NamespacedUsers uses one of the namespaced clients based on the - * value of useOidc. This reduces code duplication, allowing us to - * reuse the same implementation for several test iterfaces. - */ - private class NamespacedUsers implements - ClientUsersTestSuite.DbUsers, ClientUsersTestSuite.OidcUsers { - private final DbUsers db; - private final OidcUsers oidc; - private final boolean useOidc; - - public NamespacedUsers(boolean useOidc) { - this.db = users.db(); - this.oidc = users.oidc(); - this.useOidc = useOidc; - } - - @Override - public Result assignRoles(String user, String... roles) { - return useOidc - ? rethrow(() -> oidc.assigner().withUserId(user).witRoles(roles).run()) - : rethrow(() -> db.assigner().withUserId(user).witRoles(roles).run()); - } - - @Override - public Result revokeRoles(String user, String... roles) { - return useOidc - ? rethrow(() -> oidc.revoker().withUserId(user).witRoles(roles).run()) - : rethrow(() -> db.revoker().withUserId(user).witRoles(roles).run()); - } - - @Override - public Result> getAssignedRoles(String user, boolean includePermissions) { - return useOidc - ? rethrow(() -> oidc.userRolesGetter().withUserId(user).includePermissions(includePermissions).run()) - : rethrow(() -> db.userRolesGetter().withUserId(user).includePermissions(includePermissions).run()); - } - - @Override - public Result create(String user) { - return rethrow(() -> db.creator().withUserId(user).run()); - } - - @Override - public Result rotateKey(String user) { - return rethrow(() -> db.keyRotator().withUserId(user).run()); - } - - @Override - public Result delete(String user) { - return rethrow(() -> db.deleter().withUserId(user).run()); - } - - @Override - public Result activate(String user) { - return rethrow(() -> db.activator().withUserId(user).run()); - } - - @Override - public Result deactivate(String user, boolean revokeKey) { - return rethrow(() -> db.deactivator().withUserId(user).run()); - } - - @Override - public Result getUser(String user) { - return rethrow(() -> db.getUser().withUserId(user).run()); - } - - @Override - public Result> getAll() { - return rethrow(() -> db.allGetter().run()); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthAzureClientCredentialsTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthAzureClientCredentialsTest.java deleted file mode 100644 index f2b592031..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthAzureClientCredentialsTest.java +++ /dev/null @@ -1,71 +0,0 @@ -package io.weaviate.integration.client.auth; - -import java.util.Arrays; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithAzureContainer; -import org.apache.commons.lang3.StringUtils; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Ignore; -import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.ClientCredentialsFlow; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; - -public class AuthAzureClientCredentialsTest { - private String address; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithAzureContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - @Ignore("client secret expired") - public void testAuthAzure() throws AuthException { - String clientSecret = System.getenv("AZURE_CLIENT_SECRET"); - if (StringUtils.isNotBlank(clientSecret)) { - Config config = new Config("http", address); - ClientCredentialsFlow clientCredentialsFlow = new ClientCredentialsFlow(clientSecret); - WeaviateClient client = clientCredentialsFlow.getAuthClient(config, Arrays.asList("4706508f-30c2-469b-8b12-ad272b3de864/.default")); - Result meta = client.misc().metaGetter().run(); - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } else { - System.out.println("Skipping Azure Client Credentials test, missing AZURE_CLIENT_SECRET"); - } - } - - @Test - @Ignore("client secret expired") - public void testAuthAzureHardcodedScope() throws AuthException { - String clientSecret = System.getenv("AZURE_CLIENT_SECRET"); - if (StringUtils.isNotBlank(clientSecret)) { - Config config = new Config("http", address); - ClientCredentialsFlow clientCredentialsFlow = new ClientCredentialsFlow(clientSecret); - WeaviateClient client = clientCredentialsFlow.getAuthClient(config, null); - Result meta = client.misc().metaGetter().run(); - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } else { - System.out.println("Skipping Azure Client Credentials test, missing AZURE_CLIENT_SECRET"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthOktaClientCredentialsTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthOktaClientCredentialsTest.java deleted file mode 100644 index e71c2ca0e..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthOktaClientCredentialsTest.java +++ /dev/null @@ -1,51 +0,0 @@ -package io.weaviate.integration.client.auth; - -import java.util.Arrays; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithOktaCcContainer; -import org.apache.commons.lang3.StringUtils; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.ClientCredentialsFlow; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; - -public class AuthOktaClientCredentialsTest { - private String address; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOktaCcContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - public void testAuthOkta() throws AuthException { - String clientSecret = System.getenv("OKTA_CLIENT_SECRET"); - if (StringUtils.isNotBlank(clientSecret)) { - Config config = new Config("http", address); - ClientCredentialsFlow clientCredentialsFlow = new ClientCredentialsFlow(clientSecret); - WeaviateClient client = clientCredentialsFlow.getAuthClient(config, Arrays.asList("some_scope")); - Result meta = client.misc().metaGetter().run(); - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } else { - System.out.println("Skipping Okta Client Credentials test, missing OKTA_CLIENT_SECRET"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthOktaUsersTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthOktaUsersTest.java deleted file mode 100644 index c7888437c..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthOktaUsersTest.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.integration.client.auth; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithOktaUsersContainer; -import org.apache.commons.lang3.StringUtils; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.ResourceOwnerPasswordFlow; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; - -public class AuthOktaUsersTest { - private String address; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOktaUsersContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - public void testAuthOktaNoScope() throws AuthException { - String password = System.getenv("OKTA_DUMMY_CI_PW"); - if (StringUtils.isNotBlank(password)) { - Config config = new Config("http", address); - String username = "test@test.de"; - ResourceOwnerPasswordFlow resourceOwnerPasswordFlow = new ResourceOwnerPasswordFlow(username, password); - WeaviateClient client = resourceOwnerPasswordFlow.getAuthClient(config, null); - Result meta = client.misc().metaGetter().run(); - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } else { - System.out.println("Skipping Okta test, missing OKTA_DUMMY_CI_PW"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersApiKeyTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersApiKeyTest.java deleted file mode 100644 index 358250c3e..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersApiKeyTest.java +++ /dev/null @@ -1,128 +0,0 @@ -package io.weaviate.integration.client.auth; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.Meta; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithOidcContainer; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; -import static org.assertj.core.api.Assertions.assertThat; -import org.testcontainers.weaviate.WeaviateContainer; - -public class AuthWCSUsersApiKeyTest { - - private static String httpHostAddress; - private static String grpcHost; - private static Integer grpcPort; - private static final String API_KEY = "my-secret-key"; - private static final String INVALID_API_KEY = "my-not-so-secret-key"; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOidcContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - httpHostAddress = weaviate.getHttpHostAddress(); - grpcHost = weaviate.getHost(); - grpcPort = weaviate.getMappedPort(50051); - } - - @Test - public void shouldAuthenticateWithValidApiKey() throws AuthException { - Config config = new Config("http", httpHostAddress); - WeaviateClient client = WeaviateAuthClient.apiKey(config, API_KEY); - Result meta = client.misc().metaGetter().run(); - - assertThat(meta).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .returns("http://[::]:8080", Meta::getHostname) - .returns(EXPECTED_WEAVIATE_VERSION, Meta::getVersion); - } - - @Test - public void shouldNotAuthenticateWithInvalidApiKey() throws AuthException { - Config config = new Config("http", httpHostAddress); - WeaviateClient client = WeaviateAuthClient.apiKey(config, INVALID_API_KEY); - Result meta = client.misc().metaGetter().run(); - - assertThat(meta).isNotNull() - .returns(true, Result::hasErrors) - .returns(null, Result::getResult) - .extracting(Result::getError) - .returns(401, WeaviateError::getStatusCode); - } - - @Test - public void shouldAuthenticateWithValidApiKeyUsingGRPC() throws AuthException, InterruptedException { - Config config = new Config("http", httpHostAddress); - config.setGRPCHost(grpcHost + ":" + grpcPort); - WeaviateClient client = WeaviateAuthClient.apiKey(config, API_KEY); - // TODO: temporary solution to make the tests pass - Thread.sleep(1000); - - Result deleteAll = client.schema().allDeleter().run(); - assertThat(deleteAll).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isEqualTo(Boolean.TRUE); - - String id = "00000000-0000-0000-0000-000000000001"; - String className = "TestGRPC"; - String propertyName = "name"; - List properties = new ArrayList<>(); - properties.add(Property.builder().name("name").dataType(Collections.singletonList(DataType.TEXT)).build()); - WeaviateClass clazz = WeaviateClass.builder().className(className).properties(properties).build(); - Result createClass = client.schema().classCreator().withClass(clazz).run(); - - assertThat(createClass).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Map props = new HashMap<>(); - props.put("name", "John Doe"); - - WeaviateObject obj = WeaviateObject.builder().id(id).className(className).properties(props).build(); - - Result result = client.batch().objectsBatcher() - .withObjects(obj) - .run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(1); - - Result> resultObj = client.data().objectsGetter().withClassName(className).withID(id).run(); - assertThat(resultObj).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(r -> r.get(0)).isNotNull() - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(obj.getId()); - assertThat(o.getProperties()).isNotNull() - .extracting(Map::size).isEqualTo(obj.getProperties().size()); - assertThat(o.getProperties()).isNotEmpty().satisfies(p -> { - assertThat(p.get(propertyName)).isNotNull(); - }); - }); - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersResourceOwnerTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersResourceOwnerTest.java deleted file mode 100644 index 44b6cee62..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthWCSUsersResourceOwnerTest.java +++ /dev/null @@ -1,50 +0,0 @@ -package io.weaviate.integration.client.auth; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithOidcContainer; -import org.apache.commons.lang3.StringUtils; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.ResourceOwnerPasswordFlow; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; - -public class AuthWCSUsersResourceOwnerTest { - private String address; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOidcContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - public void testAuthWCS() throws AuthException { - String password = System.getenv("WCS_DUMMY_CI_PW"); - if (StringUtils.isNotBlank(password)) { - Config config = new Config("http", address); - String username = "oidc-test-user@weaviate.io"; - ResourceOwnerPasswordFlow resourceOwnerPasswordFlow = new ResourceOwnerPasswordFlow(username, password); - WeaviateClient client = resourceOwnerPasswordFlow.getAuthClient(config, null); - Result meta = client.misc().metaGetter().run(); - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } else { - System.out.println("Skipping WCS test, missing WCS_DUMMY_CI_PW"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/AuthWeaviateEmbeddingHeadersTest.java b/src/test/java/io/weaviate/integration/client/auth/AuthWeaviateEmbeddingHeadersTest.java deleted file mode 100644 index 6c8d2a890..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/AuthWeaviateEmbeddingHeadersTest.java +++ /dev/null @@ -1,125 +0,0 @@ -package io.weaviate.integration.client.auth; - -import static org.junit.Assert.assertNull; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.WeaviateClass; - -/** - * Local test for authentication to Weaviate Embeddings service. - * To run it, remove {@code @Ignore} annotation below and set these - * environment variables: - * - *
{@code
- *  export WEAVIATE_REST_HOST=""
- *  export WEAVIATE_GRPC_HOST=""
- *  export WEAVIATE_API_KEY=""
- * }
- */ -@Ignore -public class AuthWeaviateEmbeddingHeadersTest { - - private static final String apiKey = System.getenv("WEAVIATE_API_KEY"); - private static final String REST_HOST = System.getenv("WEAVIATE_REST_HOST"); - private static final String GRPC_HOST = System.getenv("WEAVIATE_GRPC_HOST"); - private static final String EMBEDDING_MODEL = "Snowflake/snowflake-arctic-embed-l-v2.0"; - private static final String DEMO_COLLECTION = "DemoCollection"; - - private WeaviateClient client; - - @Before - public void beforeEach() { - Config config = new Config("https", REST_HOST, true, GRPC_HOST); - client = assertDoesNotThrow(() -> WeaviateAuthClient.apiKey(config, apiKey), "create auth client"); - - // Delete DemoCollection - client.schema().classDeleter().withClassName(DEMO_COLLECTION).run(); - } - - /** - * Following this guide: - * https://weaviate.io/developers/wcs/embeddings/quickstart#requirements we - * expect that there will be no errors. - */ - @Test - public void testWeaviateHeaders() { - createCollection(client); - assertDoesNotThrow(() -> importObjects(client)); - } - - private void createCollection(WeaviateClient client) { - Map text2vecWeaviate = new HashMap<>(); - Map text2vecWeaviateSettings = new HashMap<>(); - - text2vecWeaviateSettings.put("properties", new String[] { "title" }); - text2vecWeaviateSettings.put("model", new String[] { EMBEDDING_MODEL }); - text2vecWeaviateSettings.put("dimensions", new Integer[] { 1024 }); // 1024, 256 - text2vecWeaviateSettings.put("base_url", new String[] { REST_HOST }); - text2vecWeaviate.put("text2vec-weaviate", text2vecWeaviateSettings); - - // Define the vector configurations - Map vectorConfig = new HashMap<>(); - vectorConfig.put("title_vector", WeaviateClass.VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(text2vecWeaviate) - .build()); - - // Create the collection "DemoCollection" - WeaviateClass clazz = WeaviateClass.builder() - .className(DEMO_COLLECTION) - .vectorConfig(vectorConfig) - .build(); - - Result result = client.schema().classCreator().withClass(clazz).run(); - assertNull("successfully created DemoCollection", result.getError()); - } - - private void importObjects(WeaviateClient client) { - Map object1 = new HashMap() { - { - this.put("title", "Object One"); - } - }; - - List> sourceObjects = new ArrayList>() { - { - this.add(object1); - } - }; - List> objects = new ArrayList<>(); - for (Map sourceObject : sourceObjects) { - HashMap schema = new HashMap<>(); - schema.put("title", sourceObject.get("title")); - schema.put("description", sourceObject.get("description")); - objects.add(schema); - } - - // Batch write items - ObjectsBatcher batcher = client.batch().objectsBatcher(); - for (Map properties : objects) { - batcher.withObject(WeaviateObject.builder() - .className(DEMO_COLLECTION) - .properties(properties) - .build()); - } - - // Flush - Result result = batcher.run(); - assertNull("successfully imported objects", result.getError()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthClientCredentialsRefreshTokenTest.java b/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthClientCredentialsRefreshTokenTest.java deleted file mode 100644 index 49fb68544..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthClientCredentialsRefreshTokenTest.java +++ /dev/null @@ -1,79 +0,0 @@ -package io.weaviate.integration.client.auth.provider; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateVersion; -import java.util.Arrays; -import java.util.List; - -import io.weaviate.integration.client.WeaviateWithOktaCcContainer; -import org.apache.commons.lang3.StringUtils; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.nimbus.AuthType; -import io.weaviate.client.v1.auth.nimbus.BaseAuth; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.auth.provider.AuthClientCredentialsTokenProvider; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -public class NimbusAuthClientCredentialsRefreshTokenTest { - private String address; - private AccessTokenProvider tokenProvider; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOktaCcContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - public void testAuthOkta() throws AuthException, InterruptedException { - class NimbusAuthAuthImpl extends NimbusAuth { - @Override - protected AccessTokenProvider getTokenProvider(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, - String accessToken, long accessTokenLifeTime, String refreshToken, String clientSecret, AuthType authType) { - // Client Credentials flow - tokenProvider = new AuthClientCredentialsTokenProvider(config, authResponse, clientScopes, accessToken, 2l, clientSecret); - return tokenProvider; - } - } - - String clientSecret = System.getenv("OKTA_CLIENT_SECRET"); - if (StringUtils.isNotBlank(clientSecret)) { - Config config = new Config("http", address); - assertThat(tokenProvider).isNull(); - NimbusAuthAuthImpl nimbusAuth = new NimbusAuthAuthImpl(); - AccessTokenProvider provider = nimbusAuth.getAccessTokenProvider(config, clientSecret, "", "", Arrays.asList("some_scope"), AuthType.CLIENT_CREDENTIALS); - WeaviateClient client = new WeaviateClient(config, provider); - assertThat(tokenProvider).isNotNull(); - // get the access token - String firstBearerAccessTokenHeader = tokenProvider.getAccessToken(); - assertThat(firstBearerAccessTokenHeader).isNotBlank(); - Result meta = client.misc().metaGetter().run(); - assertThat(meta).isNotNull(); - assertThat(meta.getError()).isNull(); - assertThat(meta.getResult().getHostname()).isEqualTo("http://[::]:8080"); - assertThat(meta.getResult().getVersion()).isEqualTo(WeaviateVersion.EXPECTED_WEAVIATE_VERSION); - Thread.sleep(3000l); - // get the access token after refresh - String afterRefreshBearerAccessTokenHeader = tokenProvider.getAccessToken(); - assertThat(firstBearerAccessTokenHeader).isNotEqualTo(afterRefreshBearerAccessTokenHeader); - meta = client.misc().metaGetter().run(); - assertThat(meta).isNotNull(); - assertThat(meta.getError()).isNull(); - assertThat(meta.getResult().getHostname()).isEqualTo("http://[::]:8080"); - assertThat(meta.getResult().getVersion()).isEqualTo(WeaviateVersion.EXPECTED_WEAVIATE_VERSION); - } else { - System.out.println("Skipping Okta Client Credentials refresh token test, missing OKTA_CLIENT_SECRET"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthRefreshTokenTest.java b/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthRefreshTokenTest.java deleted file mode 100644 index eb0b7e5fb..000000000 --- a/src/test/java/io/weaviate/integration/client/auth/provider/NimbusAuthRefreshTokenTest.java +++ /dev/null @@ -1,79 +0,0 @@ -package io.weaviate.integration.client.auth.provider; - -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateVersion; -import java.util.List; - -import io.weaviate.integration.client.WeaviateWithOidcContainer; -import org.apache.commons.lang3.StringUtils; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.auth.nimbus.AuthType; -import io.weaviate.client.v1.auth.nimbus.BaseAuth; -import io.weaviate.client.v1.auth.nimbus.NimbusAuth; -import io.weaviate.client.v1.auth.provider.AccessTokenProvider; -import io.weaviate.client.v1.auth.provider.AuthRefreshTokenProvider; -import io.weaviate.client.v1.misc.model.Meta; -import org.testcontainers.weaviate.WeaviateContainer; - -public class NimbusAuthRefreshTokenTest { - private String address; - private AccessTokenProvider tokenProvider; - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithOidcContainer(WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE); - - @Before - public void before() { - address = weaviate.getHttpHostAddress(); - } - - @Test - public void testAuthWCS() throws AuthException, InterruptedException { - class NimbusAuthAuthImpl extends NimbusAuth { - @Override - protected AccessTokenProvider getTokenProvider(Config config, BaseAuth.AuthResponse authResponse, List clientScopes, - String accessToken, long accessTokenLifeTime, String refreshToken, String clientSecret, AuthType authType) { - // User Password flow - tokenProvider = new AuthRefreshTokenProvider(config, authResponse, accessToken, 2l, refreshToken); - return tokenProvider; - } - } - - String password = System.getenv("WCS_DUMMY_CI_PW"); - if (StringUtils.isNotBlank(password)) { - Config config = new Config("http", address); - String username = "oidc-test-user@weaviate.io"; - assertThat(tokenProvider).isNull(); - NimbusAuthAuthImpl nimbusAuth = new NimbusAuthAuthImpl(); - AccessTokenProvider provider = nimbusAuth.getAccessTokenProvider(config, "", username, password, null, AuthType.USER_PASSWORD); - WeaviateClient client = new WeaviateClient(config, provider); - assertThat(tokenProvider).isNotNull(); - // get the access token - String firstBearerAccessTokenHeader = tokenProvider.getAccessToken(); - assertThat(firstBearerAccessTokenHeader).isNotBlank(); - Result meta = client.misc().metaGetter().run(); - assertThat(meta).isNotNull(); - assertThat(meta.getError()).isNull(); - assertThat(meta.getResult().getHostname()).isEqualTo("http://[::]:8080"); - assertThat(meta.getResult().getVersion()).isEqualTo(WeaviateVersion.EXPECTED_WEAVIATE_VERSION); - Thread.sleep(3000l); - // get the access token after refresh - String afterRefreshBearerAccessTokenHeader = tokenProvider.getAccessToken(); - assertThat(firstBearerAccessTokenHeader).isNotEqualTo(afterRefreshBearerAccessTokenHeader); - meta = client.misc().metaGetter().run(); - assertThat(meta).isNotNull(); - assertThat(meta.getError()).isNull(); - assertThat(meta.getResult().getHostname()).isEqualTo("http://[::]:8080"); - assertThat(meta.getResult().getVersion()).isEqualTo(WeaviateVersion.EXPECTED_WEAVIATE_VERSION); - } else { - System.out.println("Skipping WCS Refresh Token test, missing WCS_DUMMY_CI_PW"); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/backup/ClientBackupTest.java b/src/test/java/io/weaviate/integration/client/backup/ClientBackupTest.java deleted file mode 100644 index 7c8fabc8b..000000000 --- a/src/test/java/io/weaviate/integration/client/backup/ClientBackupTest.java +++ /dev/null @@ -1,573 +0,0 @@ -package io.weaviate.integration.client.backup; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; -import java.util.concurrent.Callable; -import java.util.function.Function; -import java.util.function.Supplier; - -import org.assertj.core.api.Assertions; -import org.jetbrains.annotations.NotNull; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.backup.api.BackupCreator; -import io.weaviate.client.v1.backup.api.BackupRestorer; -import io.weaviate.client.v1.backup.api.BackupRestorer.BackupRestoreConfig; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; -import io.weaviate.client.v1.backup.model.RbacRestoreOption; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.rbac.model.ClusterPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerComposeBackup; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.backup.BackupTestSuite; - -public class ClientBackupTest { - - private String backupId; - private String notExistingBackupId; - private WeaviateClient client; - - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - private final static Random rand = new Random(); - - @Rule - public TestName currentTest = new TestName(); - - @ClassRule - public static WeaviateDockerComposeBackup compose = new WeaviateDockerComposeBackup(); - - @Before - public void before() throws AuthException { - Config config = new Config("http", compose.getHttpHostAddress()); - client = WeaviateAuthClient.apiKey(config, WeaviateDockerComposeBackup.ADMIN_KEY); - testGenerics.createTestSchemaAndData(client); - - backupId = String.format("backup-%s-%s", currentTest.getMethodName().toLowerCase(), - rand.nextInt(Integer.MAX_VALUE)); - notExistingBackupId = "not-existing-backup-" + backupId; - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateAndRestoreBackupWithWaiting() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testCreateAndRestoreBackupWithWaiting(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, supplierDeleteClass, createSupplierGQLOfClass(), backupId); - } - - @Test - public void shouldCreateAndRestoreBackupWithoutWaiting() throws InterruptedException { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testCreateAndRestoreBackupWithoutWaiting(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, supplierDeleteClass, createSupplierGQLOfClass(), backupId); - } - - @Test - public void shouldCreateAndRestoreBackupWithDynamicLocation() throws InterruptedException { - String bucket = "test-bucket"; // irrelevant for "filesystem" backend, here only to illustrate - String path = "/custom/backup/location"; - - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(BackupCreator.BackupCreateConfig.builder().bucket(bucket).path(path).build()) - .run(); - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withBucket(bucket) - .withPath(path) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(BackupRestorer.BackupRestoreConfig.builder().bucket(bucket).path(path).build()) - .run(); - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withBucket(bucket) - .withPath(path) - .run(); - - BackupTestSuite.testCreateWithDynamicLocation(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, supplierDeleteClass, createSupplierGQLOfClass(), backupId, - bucket, path); - } - - @Test - public void shouldCreateAndRestore1Of2Classes() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testCreateAndRestore1Of2Classes(supplierCreateResult, supplierCreateStatusResult, - supplierRestoreResult, supplierRestoreStatusResult, supplierDeleteClass, createSupplierGQLOfClass(), backupId); - } - - @Test - public void shouldListCreatedBackups() { - List>> createSuppliers = new ArrayList>>() { - { - this.add(() -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId + "-1") - .withWaitForCompletion(true) - .run()); - this.add(() -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId + "-2") - .withWaitForCompletion(true) - .run()); - } - }; - - Supplier> supplierGetResult = () -> client.backup().getter() - .withBackend(BackupTestSuite.BACKEND).run(); - - BackupTestSuite.testListExistingBackups(createSuppliers, supplierGetResult); - } - - @Test - public void shouldFailOnCreateBackupOnNotExistingBackend() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnCreateBackupOnNotExistingBackend(supplierCreateResult); - } - - @Test - public void shouldFailOnCreateBackupStatusOnNotExistingBackend() { - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnCreateBackupStatusOnNotExistingBackend(supplierCreateStatusResult); - } - - @Test - public void shouldFailOnRestoreBackupFromNotExistingBackend() { - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.NOT_EXISTING_BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnRestoreBackupFromNotExistingBackend(supplierRestoreResult); - } - - @Test - public void shouldFailOnCreateBackupForNotExistingClass() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnCreateBackupForNotExistingClass(supplierCreateResult); - } - - @Test - public void shouldFailOnRestoreBackupForExistingClass() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - - BackupTestSuite.testFailOnRestoreBackupForExistingClass(supplierCreateResult, supplierRestoreResult, backupId); - } - - @Test - public void shouldFailOnCreateOfExistingBackup() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - - BackupTestSuite.testFailOnCreateOfExistingBackup(supplierCreateResult, backupId); - } - - @Test - public void shouldFailOnCreateStatusOfNotExistingBackup() { - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(notExistingBackupId) - .run(); - - BackupTestSuite.testFailOnCreateStatusOfNotExistingBackup(supplierCreateStatusResult, notExistingBackupId); - } - - @Test - public void shouldFailOnRestoreOfNotExistingBackup() { - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.NOT_EXISTING_CLASS_NAME) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(notExistingBackupId) - .run(); - - BackupTestSuite.testFailOnRestoreOfNotExistingBackup(supplierRestoreResult, notExistingBackupId); - } - - @Test - public void shouldFailOnRestoreBackupStatusOfNotStartedRestore() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnRestoreBackupStatusOfNotStartedRestore(supplierCreateResult, supplierRestoreStatusResult, - backupId); - } - - @Test - public void shouldFailOnCreateBackupForBothIncludeAndExcludeClasses() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withExcludeClassNames(BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - - BackupTestSuite.testFailOnCreateBackupForBothIncludeAndExcludeClasses(supplierCreateResult); - } - - @Test - public void shouldFailOnRestoreBackupForBothIncludeAndExcludeClasses() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA, BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(true) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - Supplier> supplierRestoreResult = () -> client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withExcludeClassNames(BackupTestSuite.CLASS_NAME_SOUP) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testFailOnRestoreBackupForBothIncludeAndExcludeClasses(supplierCreateResult, supplierRestoreResult, - supplierDeleteClass); - } - - @Test - public void shouldCreateAndRestoreBackupWithWaitingWithConfig() { - // config with too high value - Supplier> supplierCreateInvConfigResult = () -> { - BackupCreator.BackupCreateConfig config = BackupCreator.BackupCreateConfig.builder() - .cpuPercentage(801) - .build(); - - return client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(config) - .withWaitForCompletion(true) - .run(); - }; - // valid config - Supplier> supplierCreateResult = () -> { - BackupCreator.BackupCreateConfig config = BackupCreator.BackupCreateConfig.builder() - .cpuPercentage(80) - .chunkSize(512) - .compressionLevel(BackupCreator.BackupCompression.BEST_SPEED) - .build(); - - return client.backup().creator() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(config) - .withWaitForCompletion(true) - .run(); - }; - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierDeleteClass = () -> client.schema().classDeleter() - .withClassName(BackupTestSuite.CLASS_NAME_PIZZA) - .run(); - // config with too high value - Supplier> supplierRestoreInvConfigResult = () -> { - BackupRestorer.BackupRestoreConfig restoreConfig = BackupRestorer.BackupRestoreConfig.builder() - .cpuPercentage(90) - .build(); - - return client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(restoreConfig) - .withWaitForCompletion(true) - .run(); - }; - // valid config - Supplier> supplierRestoreResult = () -> { - BackupRestorer.BackupRestoreConfig restoreConfig = BackupRestorer.BackupRestoreConfig.builder() - .cpuPercentage(70) - .build(); - - return client.backup().restorer() - .withIncludeClassNames(BackupTestSuite.CLASS_NAME_PIZZA) - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withConfig(restoreConfig) - .withWaitForCompletion(true) - .run(); - }; - Supplier> supplierRestoreStatusResult = () -> client.backup() - .restoreStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testCreateAndRestoreBackupWithWaitingWithConfig(supplierCreateInvConfigResult, supplierCreateResult, - supplierCreateStatusResult, supplierRestoreInvConfigResult, supplierRestoreResult, supplierRestoreStatusResult, - supplierDeleteClass, createSupplierGQLOfClass(), backupId); - } - - @Test - public void shouldCancelBackup() { - Supplier> supplierCreateResult = () -> client.backup().creator() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withWaitForCompletion(false) // this will allow us to "intercept" the backup in progress - .run(); - Supplier> supplierCancelResult = () -> client.backup().canceler() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - Supplier> supplierCreateStatusResult = () -> client.backup().createStatusGetter() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .run(); - - BackupTestSuite.testCancelBackup(supplierCreateResult, supplierCancelResult, supplierCreateStatusResult); - } - - @Test - public void shouldRestoreWithRbacOptions() { - final String className = "RolesUsers"; - final String roleName = "restoreRole"; - final String userName = "restoreUser"; - - BackupTestSuite.testBackupRestoreWithRbacOptions(backupId, - // Arrange: create collection, create role, create user; - () -> { - client.schema().classDeleter().withClassName(className).run(); - client.schema().classCreator().withClass(WeaviateClass.builder().className(className).build()).run(); - - client.roles().deleter().withName(roleName).run(); - Result createRole = client.roles().creator().withName(roleName) - .withPermissions(Permission.cluster(ClusterPermission.Action.READ)).run(); - Assertions.assertThat(createRole.getError()).as("create role").isNull(); - - client.users().db().deleter().withUserId(userName).run(); - Result createUser = client.users().db().creator().withUserId(userName).run(); - Assertions.assertThat(createUser.getError()).as("create user").isNull(); - }, - () -> { - client.schema().classDeleter().withClassName(className).run(); - client.roles().deleter().withName(roleName).run(); - client.users().db().deleter().withUserId(userName).run(); - }, - // Create backup - () -> client.backup().creator() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withIncludeClassNames("RolesUsers") - .withWaitForCompletion(true) - .run(), - // Restore from backup - () -> client.backup().restorer() - .withBackend(BackupTestSuite.BACKEND) - .withBackupId(backupId) - .withIncludeClassNames("RolesUsers") - .withWaitForCompletion(true) - .withConfig(BackupRestoreConfig.builder() - .usersRestore(RbacRestoreOption.ALL) - .rolesRestore(RbacRestoreOption.ALL) - .build()) - .run(), - () -> client.users().db().getUser().withUserId(userName).run(), - () -> client.roles().getter().withName(roleName).run()); - } - - @Test - public void testOverwriteAlias_true() throws Exception { - String originalClass = "CollectionOverwriteAlias"; - String alias = originalClass + "Alias"; - String differentClass = "Different" + originalClass; - - Runnable arrange = () -> { - Result res; - - res = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(originalClass).build()) - .run(); - Assertions.assertThat(res.getError()).isNull(); - res = client.alias().creator().withClassName(originalClass).withAlias(alias).run(); - Assertions.assertThat(res.getError()).isNull(); - - res = client.backup().creator() - .withBackupId(backupId) - .withBackend(BackupTestSuite.BACKEND) - .withIncludeClassNames(originalClass) - .withWaitForCompletion(true) - .run(); - Assertions.assertThat(res.getError()).isNull(); - - res = client.schema().classDeleter().withClassName(originalClass).run(); - Assertions.assertThat(res.getError()).isNull(); - res = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(differentClass).build()) - .run(); - Assertions.assertThat(res.getError()).isNull(); - res = client.alias().updater().withAlias(alias).withNewClassName(differentClass).run(); - Assertions.assertThat(res.getError()).isNull(); - }; - - Callable> act = () -> client.backup().restorer() - .withBackupId(backupId) - .withBackend(BackupTestSuite.BACKEND) - .withIncludeClassNames(originalClass) - .withWaitForCompletion(true) - .withOverwriteAlias(true) - .run(); - - Supplier getAlias = () -> client.alias().getter().withAlias(alias).run().getResult(); - - BackupTestSuite.testOverwriteAlias_true(arrange, act, getAlias, originalClass); - } - - @NotNull - private Function> createSupplierGQLOfClass() { - return (String className) -> client.graphQL().get() - .withClassName(className) - .withFields(Field.builder().name("name").build()) - .run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServer2Test.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServer2Test.java deleted file mode 100644 index b63a2d1cc..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServer2Test.java +++ /dev/null @@ -1,293 +0,0 @@ -package io.weaviate.integration.client.batch; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.integration.tests.batch.BatchObjectsMockServerTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.Delay; -import org.mockserver.verify.VerificationTimes; - -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -@RunWith(JParamsTestRunner.class) -public class ClientBatchCreateMockServer2Test { - - private WeaviateClient client; - private ClientAndServer mockServer; - private MockServerClient mockServerClient; - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8999; - - @Before - public void before() { - mockServer = startClientAndServer(MOCK_SERVER_PORT); - mockServerClient = new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT); - - mockServerClient.when( - request().withMethod("GET").withPath("/v1/meta") - ).respond( - response().withStatusCode(200).withBody(metaBody()) - ); - - Config config = new Config("http", MOCK_SERVER_HOST + ":" + MOCK_SERVER_PORT, null, 1, 1, 1); - client = new WeaviateClient(config); - } - - @After - public void stopMockServer() { - mockServer.stop(); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServer2Test.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long expectedExecMinMillis, long expectedExecMaxMillis) { - // stop server to simulate connection issues - mockServer.stop(); - - Supplier> supplierObjectsBatcher = () -> client.batch().objectsBatcher(batchRetriesConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run(); - - BatchObjectsMockServerTestSuite.testNotCreateBatchDueToConnectionIssue(supplierObjectsBatcher, - expectedExecMinMillis, expectedExecMaxMillis); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServer2Test.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateAutoBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long expectedExecMinMillis, long expectedExecMaxMillis) { - // stop server to simulate connection issues - mockServer.stop(); - - Consumer>> supplierObjectsBatcher = callback -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - client.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .flush(); - }; - - BatchObjectsMockServerTestSuite.testNotCreateAutoBatchDueToConnectionIssue(supplierObjectsBatcher, - expectedExecMinMillis, expectedExecMaxMillis); - } - - public static Object[][] provideForNotCreateBatchDueToConnectionIssue() { - return new Object[][]{ - new Object[]{ - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(0) - .build(), - 0, 350 - }, - new Object[]{ - // final response should be available after 1 retry (400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(1) - .build(), - 400, 750 - }, - new Object[]{ - // final response should be available after 2 retries (400 + 800 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(2) - .build(), - 1200, 1550 - }, - new Object[]{ - // final response should be available after 1 retry (400 + 800 + 1200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(3) - .build(), - 2400, 2750 - }, - }; - } - - @Test - @DataMethod(source = ClientBatchCreateMockServer2Test.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCallsCount) { - // given client times out after 1s - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.PIZZA_1); - String soup1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.SOUP_1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects") - ).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200) - ); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)) - ).respond( - response().withBody(pizza1Str) - ); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)) - ).respond( - response().withBody(soup1Str) - ); - - Supplier> supplierObjectsBatcher = () -> client.batch().objectsBatcher(batchRetriesConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .run(); - Consumer assertPostObjectsCallsCount = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(count) - ); - Consumer assertGetPizza1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetPizza2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_2_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetSoup1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetSoup2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_2_ID)), - VerificationTimes.exactly(count) - ); - - BatchObjectsMockServerTestSuite.testNotCreateBatchDueToTimeoutIssue(supplierObjectsBatcher, - assertPostObjectsCallsCount, assertGetPizza1CallsCount, assertGetPizza2CallsCount, - assertGetSoup1CallsCount, assertGetSoup2CallsCount, expectedBatchCallsCount, "Read timed out"); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServer2Test.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateAutoBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCallsCount) { - // given client times out after 1s - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.PIZZA_1); - String soup1Str = serializer.toJsonString(BatchObjectsMockServerTestSuite.SOUP_1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects") - ).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200) - ); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)) - ).respond( - response().withBody(pizza1Str) - ); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)) - ).respond( - response().withBody(soup1Str) - ); - - Consumer>> supplierObjectsBatcher = callback -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .poolSize(2) - .callback(callback) - .build(); - - client.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(BatchObjectsMockServerTestSuite.PIZZA_1, BatchObjectsMockServerTestSuite.PIZZA_2, - BatchObjectsMockServerTestSuite.SOUP_1, BatchObjectsMockServerTestSuite.SOUP_2) - .flush(); - }; - - Consumer assertPostObjectsCallsCount = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(count) - ); - Consumer assertGetPizza1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_1_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetPizza2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", BatchObjectsMockServerTestSuite.PIZZA_2_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetSoup1CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_1_ID)), - VerificationTimes.exactly(count) - ); - Consumer assertGetSoup2CallsCount = count -> mockServerClient.verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", BatchObjectsMockServerTestSuite.SOUP_2_ID)), - VerificationTimes.exactly(count) - ); - - BatchObjectsMockServerTestSuite.testNotCreateAutoBatchDueToTimeoutIssue(supplierObjectsBatcher, - assertPostObjectsCallsCount, assertGetPizza1CallsCount, assertGetPizza2CallsCount, - assertGetSoup1CallsCount, assertGetSoup2CallsCount, expectedBatchCallsCount, "Read timed out"); - } - - public static Object[][] provideForNotCreateBatchDueToTimeoutIssue() { - return new Object[][]{ - new Object[]{ - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(0) - .build(), - 1 - }, - new Object[]{ - // final response should be available after 1 retry (200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(1) - .build(), - 2 - }, - new Object[]{ - // final response should be available after 2 retries (200 + 400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(2) - .build(), - 3 - }, - }; - } - - private String metaBody() { - return String.format("{\n" + - " \"hostname\": \"http://[::]:%s\",\n" + - " \"modules\": {},\n" + - " \"version\": \"%s\"\n" + - "}", MOCK_SERVER_PORT, "1.17.999-mock-server-version"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServerTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServerTest.java deleted file mode 100644 index e3cf8816e..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateMockServerTest.java +++ /dev/null @@ -1,408 +0,0 @@ -package io.weaviate.integration.client.batch; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.time.ZonedDateTime; -import java.time.temporal.ChronoUnit; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.junit.After; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.Delay; -import org.mockserver.verify.VerificationTimes; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; - -@Ignore // Blocking 5.1.0-alpha1 release, will be revisited before 5.1.0. -@RunWith(JParamsTestRunner.class) -public class ClientBatchCreateMockServerTest { - - private static final String PIZZA_1_ID = "abefd256-8574-442b-9293-9205193737ee"; - private static final Map PIZZA_1_PROPS = createFoodProperties("Hawaii", - "Universally accepted to be the best pizza ever created."); - private static final String PIZZA_2_ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - private static final Map PIZZA_2_PROPS = createFoodProperties("Doener", - "A innovation, some say revolution, in the pizza industry."); - private static final String SOUP_1_ID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - private static final Map SOUP_1_PROPS = createFoodProperties("ChickenSoup", - "Used by humans when their inferior genetics are attacked by microscopic organisms."); - private static final String SOUP_2_ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - private static final Map SOUP_2_PROPS = createFoodProperties("Beautiful", - "Putting the game of letter soups to a whole new level."); - - private WeaviateClient client; - private ClientAndServer mockServer; - private MockServerClient mockServerClient; - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8999; - - @Before - public void before() { - mockServer = startClientAndServer(MOCK_SERVER_PORT); - mockServerClient = new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT); - - mockServerClient.when( - request().withMethod("GET").withPath("/v1/meta")).respond( - response().withStatusCode(200).withBody(metaBody())); - - Config config = new Config("http", MOCK_SERVER_HOST + ":" + MOCK_SERVER_PORT, null, 1, 1, 1); - client = new WeaviateClient(config); - } - - @After - public void stopMockServer() { - mockServer.stop(); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long execMin, long execMax) { - // stop server to simulate connection issues - mockServer.stop(); - - WeaviateObject[] objects = { - WeaviateObject.builder().className("Pizza").id(PIZZA_1_ID).properties(PIZZA_1_PROPS).build(), - WeaviateObject.builder().className("Pizza").id(PIZZA_2_ID).properties(PIZZA_2_PROPS).build(), - WeaviateObject.builder().className("Soup").id(SOUP_1_ID).properties(SOUP_1_PROPS).build(), - WeaviateObject.builder().className("Soup").id(SOUP_2_ID).properties(SOUP_2_PROPS).build() - }; - - ZonedDateTime start = ZonedDateTime.now(); - Result resBatch = client.batch().objectsBatcher(batchRetriesConfig) - .withObjects(objects) - .run(); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(execMin, execMax); - assertThat(resBatch.getResult()).isNull(); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains(PIZZA_1_ID, PIZZA_2_ID, SOUP_1_ID, SOUP_2_ID); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToConnectionIssue") - public void shouldNotCreateAutoBatchDueToConnectionIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - long expectedExecMinMillis, long expectedExecMaxMillis) { - // stop server to simulate connection issues - mockServer.stop(); - - WeaviateObject[] objects = { - WeaviateObject.builder().className("Pizza").id(PIZZA_1_ID).properties(PIZZA_1_PROPS).build(), - WeaviateObject.builder().className("Pizza").id(PIZZA_2_ID).properties(PIZZA_2_PROPS).build(), - WeaviateObject.builder().className("Soup").id(SOUP_1_ID).properties(SOUP_1_PROPS).build(), - WeaviateObject.builder().className("Soup").id(SOUP_2_ID).properties(SOUP_2_PROPS).build() - }; - - List> resBatches = Collections.synchronizedList(new ArrayList<>(2)); - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .poolSize(1) - .callback(resBatches::add) - .build(); - - ZonedDateTime start = ZonedDateTime.now(); - client.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(objects) - .flush(); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(expectedExecMinMillis, expectedExecMaxMillis); - assertThat(resBatches).hasSize(2); - - for (Result resBatch : resBatches) { - assertThat(resBatch.getResult()).isNull(); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedIdsMessage = errorMessages.get(1).getMessage(); - if (failedIdsMessage.contains(PIZZA_1_ID)) { - assertThat(failedIdsMessage).contains(PIZZA_1_ID, PIZZA_2_ID).doesNotContain(SOUP_1_ID, SOUP_2_ID); - } else { - assertThat(failedIdsMessage).contains(SOUP_1_ID, SOUP_2_ID).doesNotContain(PIZZA_1_ID, PIZZA_2_ID); - } - } - } - - public static Object[][] provideForNotCreateBatchDueToConnectionIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(0) - .build(), - 0, 350 - }, - new Object[] { - // final response should be available after 1 retry (400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(1) - .build(), - 400, 750 - }, - new Object[] { - // final response should be available after 2 retries (400 + 800 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(2) - .build(), - 1200, 1550 - }, - new Object[] { - // final response should be available after 1 retry (400 + 800 + 1200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(400) - .maxConnectionRetries(3) - .build(), - 2400, 2750 - }, - }; - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - WeaviateObject pizza1 = WeaviateObject.builder().className("Pizza").id(PIZZA_1_ID).properties(PIZZA_1_PROPS) - .build(); - WeaviateObject pizza2 = WeaviateObject.builder().className("Pizza").id(PIZZA_2_ID).properties(PIZZA_2_PROPS) - .build(); - WeaviateObject soup1 = WeaviateObject.builder().className("Soup").id(SOUP_1_ID).properties(SOUP_1_PROPS).build(); - WeaviateObject soup2 = WeaviateObject.builder().className("Soup").id(SOUP_2_ID).properties(SOUP_2_PROPS).build(); - WeaviateObject[] objects = { pizza1, pizza2, soup1, soup2 }; - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(pizza1); - String soup1Str = serializer.toJsonString(soup1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 - // should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_1_ID))).respond( - response().withBody(pizza1Str)); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_1_ID))).respond( - response().withBody(soup1Str)); - - Result resBatch = client.batch().objectsBatcher(batchRetriesConfig) - .withObjects(objects) - .run(); - - mockServerClient - .verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(expectedBatchCalls)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_2_ID)), - VerificationTimes.exactly(expectedBatchCalls)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_2_ID)), - VerificationTimes.exactly(expectedBatchCalls)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_1_ID)), - VerificationTimes.exactly(1)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_1_ID)), - VerificationTimes.exactly(1)); - - assertThat(resBatch.getResult()).hasSize(2); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Read timed out"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains(PIZZA_2_ID, SOUP_2_ID).doesNotContain(PIZZA_1_ID, SOUP_1_ID); - - assertThat(resBatch.getResult()[0]) - .returns(PIZZA_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - assertThat(resBatch.getResult()[1]) - .returns(SOUP_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } - - @Test - @DataMethod(source = ClientBatchCreateMockServerTest.class, method = "provideForNotCreateBatchDueToTimeoutIssue") - public void shouldNotCreateAutoBatchDueToTimeoutIssue(ObjectsBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - WeaviateObject pizza1 = WeaviateObject.builder().className("Pizza").id(PIZZA_1_ID).properties(PIZZA_1_PROPS) - .build(); - WeaviateObject pizza2 = WeaviateObject.builder().className("Pizza").id(PIZZA_2_ID).properties(PIZZA_2_PROPS) - .build(); - WeaviateObject soup1 = WeaviateObject.builder().className("Soup").id(SOUP_1_ID).properties(SOUP_1_PROPS).build(); - WeaviateObject soup2 = WeaviateObject.builder().className("Soup").id(SOUP_2_ID).properties(SOUP_2_PROPS).build(); - WeaviateObject[] objects = { pizza1, pizza2, soup1, soup2 }; - - Serializer serializer = new Serializer(); - String pizza1Str = serializer.toJsonString(pizza1); - String soup1Str = serializer.toJsonString(soup1); - - // batch request should end up with timeout exception, but Pizza1 and Soup1 - // should be "added" and available by get - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/objects")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_1_ID))).respond( - response().withBody(pizza1Str)); - mockServerClient.when( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_1_ID))).respond( - response().withBody(soup1Str)); - - List> resBatches = Collections.synchronizedList(new ArrayList<>(2)); - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .poolSize(2) - .callback(resBatches::add) - .build(); - - client.batch().objectsAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withObjects(objects) - .flush(); - - mockServerClient - .verify( - request().withMethod("POST").withPath("/v1/batch/objects"), - VerificationTimes.exactly(expectedBatchCalls * 2)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_2_ID)), - VerificationTimes.exactly(expectedBatchCalls)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_2_ID)), - VerificationTimes.exactly(expectedBatchCalls)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Pizza", PIZZA_1_ID)), - VerificationTimes.exactly(1)) - .verify( - request().withMethod("GET").withPath(String.format("/v1/objects/%s/%s", "Soup", SOUP_1_ID)), - VerificationTimes.exactly(1)); - - assertThat(resBatches).hasSize(2); - - for (Result resBatch : resBatches) { - assertThat(resBatch.getResult()).hasSize(1); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Read timed out"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedIdsMessage = errorMessages.get(1).getMessage(); - if (failedIdsMessage.contains(PIZZA_2_ID)) { - assertThat(failedIdsMessage).contains(PIZZA_2_ID).doesNotContain(PIZZA_1_ID, SOUP_1_ID, SOUP_2_ID); - assertThat(resBatch.getResult()[0]) - .returns(PIZZA_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } else { - assertThat(failedIdsMessage).contains(SOUP_2_ID).doesNotContain(PIZZA_1_ID, PIZZA_2_ID, SOUP_1_ID); - assertThat(resBatch.getResult()[0]) - .returns(SOUP_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } - } - } - - public static Object[][] provideForNotCreateBatchDueToTimeoutIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(0) - .build(), - 1 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(1) - .build(), - 2 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ObjectsBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(2) - .build(), - 3 - }, - }; - } - - private static Map createFoodProperties(String name, String description) { - Map props = new HashMap<>(); - props.put("name", name); - props.put("description", description); - - return props; - } - - private String metaBody() { - return String.format("{\n" + - " \"hostname\": \"http://[::]:%s\",\n" + - " \"modules\": {},\n" + - " \"version\": \"%s\"\n" + - "}", MOCK_SERVER_PORT, "1.17.999-mock-server-version"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateTest.java deleted file mode 100644 index 5bf9a8f37..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchCreateTest.java +++ /dev/null @@ -1,182 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchObjectsTestSuite; -import org.jetbrains.annotations.NotNull; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.List; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -public class ClientBatchCreateTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - testGenerics.createWeaviateTestSchemaFood(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateBatch() { - Function> supplierObjectsBatcherPizzas = pizza -> client.batch() - .objectsBatcher() - .withObjects(pizza, WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build()) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Function> supplierObjectsBatcherSoups = soup -> client.batch() - .objectsBatcher() - .withObjects(soup, WeaviateObject.builder() - .className("Soup") - .id(BatchObjectsTestSuite.SOUP_2_ID) - .properties(BatchObjectsTestSuite.SOUP_2_PROPS) - .build()) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - - BatchObjectsTestSuite.testCreateBatch(supplierObjectsBatcherPizzas, supplierObjectsBatcherSoups, - createSupplierDataPizza1(), createSupplierDataSoup1(), - createSupplierGetterPizza1(), createSupplierGetterPizza2(), - createSupplierGetterSoup1(), createSupplierGetterSoup2()); - } - - @Test - public void shouldCreateAutoBatch() { - BiConsumer>> supplierObjectsBatcherPizzas = (pizza, - callback) -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - client.batch().objectsAutoBatcher(autoBatchConfig) - .withObjects(pizza, WeaviateObject.builder().className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build()) - .flush(); - }; - BiConsumer>> supplierObjectsBatcherSoups = (soup, - callback) -> { - ObjectsBatcher.AutoBatchConfig autoBatchConfig = ObjectsBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - client.batch().objectsAutoBatcher(autoBatchConfig) - .withObjects(soup, WeaviateObject.builder() - .className("Soup") - .id(BatchObjectsTestSuite.SOUP_2_ID) - .properties(BatchObjectsTestSuite.SOUP_2_PROPS) - .build()) - .flush(); - }; - - BatchObjectsTestSuite.testCreateAutoBatch(supplierObjectsBatcherPizzas, supplierObjectsBatcherSoups, - createSupplierDataPizza1(), createSupplierDataSoup1(), - createSupplierGetterPizza1(), createSupplierGetterPizza2(), - createSupplierGetterSoup1(), createSupplierGetterSoup2()); - } - - @Test - public void shouldCreateBatchWithPartialError() { - Supplier> supplierObjectsBatcherPizzas = () -> { - WeaviateObject pizzaWithError = WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_1_ID) - .properties(BatchObjectsTestSuite.createFoodProperties(1, "This pizza should throw a invalid name error")) - .build(); - WeaviateObject pizza = WeaviateObject.builder() - .className("Pizza") - .id(BatchObjectsTestSuite.PIZZA_2_ID) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build(); - - return client.batch().objectsBatcher() - .withObjects(pizzaWithError, pizza) - .run(); - }; - - BatchObjectsTestSuite.testCreateBatchWithPartialError(supplierObjectsBatcherPizzas, - createSupplierGetterPizza1(), createSupplierGetterPizza2()); - } - - @NotNull - private Supplier> createSupplierDataSoup1() { - return () -> client.data().creator() - .withClassName("Soup") - .withID(BatchObjectsTestSuite.SOUP_1_ID) - .withProperties(BatchObjectsTestSuite.SOUP_1_PROPS) - .run(); - } - - @NotNull - private Supplier> createSupplierDataPizza1() { - return () -> client.data().creator() - .withClassName("Pizza") - .withID(BatchObjectsTestSuite.PIZZA_1_ID) - .withProperties(BatchObjectsTestSuite.PIZZA_1_PROPS) - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterPizza1() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.PIZZA_1_ID) - .withClassName("Pizza") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterPizza2() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.PIZZA_2_ID) - .withClassName("Pizza") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterSoup1() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.SOUP_1_ID) - .withClassName("Soup") - .run(); - } - - @NotNull - private Supplier>> createSupplierGetterSoup2() { - return () -> client.data().objectsGetter() - .withID(BatchObjectsTestSuite.SOUP_2_ID) - .withClassName("Soup") - .run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchDeleteTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchDeleteTest.java deleted file mode 100644 index 0a971256e..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchDeleteTest.java +++ /dev/null @@ -1,89 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchDeleteOutput; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.ClientBatchDeleteTestSuite; -import java.util.List; -import java.util.function.Function; -import java.util.function.Supplier; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientBatchDeleteTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics.createTestSchemaAndData(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - Supplier>> getObjects = () -> client.data().objectsGetter().run(); - - @Test - public void testBatchDeleteDryRunVerbose() { - Function> batchDelete = (whereFilter) -> client.batch().objectsBatchDeleter() - .withDryRun(true) - .withOutput(BatchDeleteOutput.VERBOSE) - .withClassName("Pizza") - .withWhere(whereFilter) - .run(); - ClientBatchDeleteTestSuite.testBatchDeleteDryRunVerbose(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteDryRunMinimal() { - Function> batchDelete = (whereFilter) -> client.batch().objectsBatchDeleter() - .withDryRun(true) - .withOutput(BatchDeleteOutput.MINIMAL) - .withClassName("Soup") - .withWhere(whereFilter) - .run(); - ClientBatchDeleteTestSuite.testBatchDeleteDryRunMinimal(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteNoMatchWithDefaultOutputAndDryRun() { - Function> batchDelete = (whereFilter) -> client.batch().objectsBatchDeleter() - .withClassName("Pizza") - .withWhere(whereFilter) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - ClientBatchDeleteTestSuite.testBatchDeleteNoMatchWithDefaultOutputAndDryRun(getObjects, batchDelete); - } - - @Test - public void testBatchDeleteAllMatchesWithDefaultDryRun() { - Function> batchDelete = (whereFilter) -> client.batch().objectsBatchDeleter() - .withOutput(BatchDeleteOutput.VERBOSE) - .withClassName("Pizza") - .withWhere(whereFilter) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - ClientBatchDeleteTestSuite.testBatchDeleteAllMatchesWithDefaultDryRun(getObjects, batchDelete); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateNamedVectorsTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateNamedVectorsTest.java deleted file mode 100644 index 79f384118..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateNamedVectorsTest.java +++ /dev/null @@ -1,88 +0,0 @@ -package io.weaviate.integration.client.batch; - -import java.util.List; -import java.util.function.Function; - -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.batch.ClientBatchGrpcCreateNamedVectorsTestSuite; - -public class ClientBatchGrpcCreateNamedVectorsTest { - private static String httpHost; - private static String grpcHost; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - httpHost = compose.getHttpHostAddress(); - grpcHost = compose.getGrpcHostAddress(); - } - - @Test - public void shouldCreateObjectsWithNamedVectors() { - WeaviateClient client = createClient(); - - Function> classCreate = (weaviateClass) -> client.schema().classCreator() - .withClass(weaviateClass) - .run(); - - Function> batchCreate = (weaviateObj) -> client.batch().objectsBatcher() - .withObjects(weaviateObj) - .run(); - - Function>> fetch = (weaviateObject) -> client.data().objectsGetter() - .withID(weaviateObject.getId()) - .withClassName(weaviateObject.getClassName()) - .withVector() - .run(); - - Function> deleteClass = (className) -> client.schema().classDeleter() - .withClassName(className).run(); - - ClientBatchGrpcCreateNamedVectorsTestSuite.shouldCreateObjectsWithNamedVectors(classCreate, batchCreate, fetch, - deleteClass); - } - - @Test - public void shouldCreateObjectsWithNamedMultiVectors() { - WeaviateClient client = createClient(); - - Function> classCreate = (weaviateClass) -> client.schema().classCreator() - .withClass(weaviateClass) - .run(); - - Function> batchCreate = (weaviateObj) -> client.batch().objectsBatcher() - .withObjects(weaviateObj) - .run(); - - Function>> fetch = (weaviateObject) -> client.data().objectsGetter() - .withID(weaviateObject.getId()) - .withClassName(weaviateObject.getClassName()) - .withVector() - .run(); - - Function> deleteClass = (className) -> client.schema().classDeleter() - .withClassName(className).run(); - - ClientBatchGrpcCreateNamedVectorsTestSuite.shouldCreateObjectsWithNamedMultiVectors(classCreate, batchCreate, fetch, - deleteClass); - } - - private WeaviateClient createClient() { - Config config = new Config("http", httpHost); - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - return new WeaviateClient(config); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateTest.java deleted file mode 100644 index e7bfc4c59..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcCreateTest.java +++ /dev/null @@ -1,114 +0,0 @@ -package io.weaviate.integration.client.batch; - -import java.util.List; -import java.util.UUID; -import java.util.function.Function; - -import org.assertj.core.api.Assertions; -import org.assertj.core.api.InstanceOfAssertFactories; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchObjectsTestSuite; -import io.weaviate.integration.tests.batch.ClientBatchGrpcCreateTestSuite; - -public class ClientBatchGrpcCreateTest { - - private static String httpHost; - private static String grpcHost; - - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - httpHost = compose.getHttpHostAddress(); - grpcHost = compose.getGrpcHostAddress(); - - WeaviateClient client = createClient(false); - - testGenerics.cleanupWeaviate(client); - testGenerics.createWeaviateTestSchemaFood(client); - } - - @Test - public void shouldCreateGRPC() { - shouldCreate(true); - } - - @Test - public void shouldCreateWithoutGRPC() { - shouldCreate(false); - } - - public void shouldCreate(boolean useGRPC) { - WeaviateClient client = createClient(useGRPC); - - Function> createClass = (weaviateClass) -> client.schema().classCreator() - .withClass(weaviateClass) - .run(); - - Function> batchCreate = (objects) -> client.batch().objectsBatcher() - .withObjects(objects) - .run(); - - Function>> fetchObject = (obj) -> client.data().objectsGetter() - .withID(obj.getId()).withClassName(obj.getClassName()).withVector() - .run(); - - Function> deleteClass = (className) -> client.schema().classDeleter() - .withClassName(className).run(); - - ClientBatchGrpcCreateTestSuite.shouldCreateBatch(client, createClass, batchCreate, fetchObject, deleteClass); - } - - @Test - public void testPartialErrorResponse() { - WeaviateClient client = createClient(true); - - WeaviateObject[] batchObjects = { - WeaviateObject.builder() - .className("Pizza") - .id(UUID.randomUUID().toString()) - .properties(BatchObjectsTestSuite.createFoodProperties(1, "This pizza should throw a invalid name error")) - .build(), - WeaviateObject.builder() - .className("Pizza") - .id(UUID.randomUUID().toString()) - .properties(BatchObjectsTestSuite.PIZZA_2_PROPS) - .build(), - }; - - Result result = client.batch().objectsBatcher() - .withObjects(batchObjects) - .run(); - - Assertions.assertThat(result) - .returns(true, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(InstanceOfAssertFactories.array(ObjectGetResponse[].class)) - .hasSameSizeAs(batchObjects).as("all batch objects included in the response"); - - Assertions.assertThat(result.getResult()[0].getResult().getErrors().getError().get(0).getMessage()) - .contains("invalid text property 'name' on class 'Pizza': not a string, but float64"); - } - - private WeaviateClient createClient(Boolean useGRPC) { - Config config = new Config("http", httpHost); - if (useGRPC) { - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - } - return new WeaviateClient(config); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcVectorBytesTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcVectorBytesTest.java deleted file mode 100644 index 0cfed99b1..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchGrpcVectorBytesTest.java +++ /dev/null @@ -1,208 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; - -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.BiConsumer; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -import org.junit.Test; -import org.testcontainers.weaviate.WeaviateContainer; - -public class ClientBatchGrpcVectorBytesTest { - - @Test - public void shouldSendVectorWith_v1_22_10() { - testWeaviate("semitechnologies/weaviate:1.22.10", - this::batchSingleObjectWithVector - ); - } - - @Test - public void shouldSendVectorWith_v1_23_10() { - testWeaviate("semitechnologies/weaviate:1.23.10", - this::batchSingleObjectWithVector - ); - } - - @Test - public void shouldSendVectorWith_v1_24_0() { - testWeaviate("semitechnologies/weaviate:1.24.0", - this::batchSingleObjectWithVector, - this::batchSingleObjectWithTargetVector - ); - } - - private void testWeaviate(String image, BiConsumer... scenarios) { - WeaviateContainer container = new WeaviateContainer(image); - try { - container.start(); - - Integer httpPort = container.getMappedPort(8080); - Integer grpcPort = container.getMappedPort(50051); - for (BiConsumer scenario : scenarios) { - scenario.accept(httpPort, grpcPort); - } - } finally { - container.stop(); - } - } - - - private void batchSingleObjectWithVector(Integer httpPort, Integer grpcPort) { - // create client - Config config = new Config("http", "localhost:" + httpPort); - config.setGRPCSecured(false); - config.setGRPCHost("localhost:" + grpcPort); - WeaviateClient client = new WeaviateClient(config); - // create schema - String className = "NoVectorizer"; - List properties = Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build()); - Result createResult = client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(className) - .properties(properties) - .build() - ) - .run(); - assertThat(createResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - // create object - String id = "00000000-0000-0000-0000-000000000001"; - Map props = new HashMap<>(); - props.put("name", "some name"); - Float[] vector = new Float[]{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}; - WeaviateObject obj = WeaviateObject.builder() - .id(id).className(className).properties(props).vector(vector) - .build(); - Result result = client.batch().objectsBatcher() - .withObjects(obj) - .run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(1); - // fetch that object - Result> resultObj = client.data().objectsGetter() - .withID(obj.getId()).withClassName(obj.getClassName()).withVector() - .run(); - assertThat(resultObj).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(r -> r.get(0)).isNotNull() - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(obj.getId()); - assertThat(o.getVector()).isNotEmpty().isEqualTo(vector); - assertThat(o.getProperties()).isNotNull() - .extracting(Map::size).isEqualTo(obj.getProperties().size()); - obj.getProperties().keySet().forEach(propName -> { - assertThat(o.getProperties().get(propName)).isNotNull(); - }); - }); - // clean up - Result delete = client.schema().classDeleter().withClassName(className).run(); - assertThat(delete).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isEqualTo(Boolean.TRUE); - } - - private void batchSingleObjectWithTargetVector(Integer httpPort, Integer grpcPort) { - // create client - Config config = new Config("http", "localhost:" + httpPort); - config.setGRPCSecured(false); - config.setGRPCHost("localhost:" + grpcPort); - WeaviateClient client = new WeaviateClient(config); - // create schema - String className = "NoVectorizerTargetVector"; - List properties = Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build()); - Map vectorizer = new HashMap<>(); - vectorizer.put("none", new Object()); - Map vectorConfig = new HashMap<>(); - vectorConfig.put("hnswVector", WeaviateClass.VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(vectorizer) - .build()); - Result createResult = client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(className) - .properties(properties) - .vectorConfig(vectorConfig) - .build() - ) - .run(); - assertThat(createResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // create object - String id = "00000000-0000-0000-0000-000000000001"; - Map props = new HashMap<>(); - props.put("name", "some name"); - Float[] vector = new Float[]{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}; - Map vectors = new HashMap<>(); - vectors.put("hnswVector", vector); - WeaviateObject obj = WeaviateObject.builder() - .id(id) - .className(className) - .properties(props) - .vectors(vectors) - .build(); - Result result = client.batch().objectsBatcher() - .withObjects(obj) - .run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(1); - - // fetch that object - Result> resultObj = client.data().objectsGetter() - .withID(obj.getId()) - .withClassName(obj.getClassName()) - .withVector() - .run(); - assertThat(resultObj).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(r -> r.get(0)).isNotNull() - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(obj.getId()); - assertThat(o.getVectors()).isNotEmpty() - .containsOnlyKeys("hnswVector") - .extracting(vecs -> vecs.get("hnswVector")).isNotNull() - .isEqualTo(vector); - assertThat(o.getProperties()).isNotNull() - .extracting(Map::size).isEqualTo(obj.getProperties().size()); - obj.getProperties().keySet().forEach(propName -> { - assertThat(o.getProperties().get(propName)).isNotNull(); - }); - }); - - // clean up - Result delete = client.schema().classDeleter().withClassName(className).run(); - assertThat(delete).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchMultiTenancyTest.java deleted file mode 100644 index a2032cbd3..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchMultiTenancyTest.java +++ /dev/null @@ -1,317 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.AssertMultiTenancy; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientBatchMultiTenancyTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - private AssertMultiTenancy assertMT; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - assertMT = new AssertMultiTenancy(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createTenantsSoup(client, tenants); - - Map propsQuatroFormaggi = new HashMap<>(); - propsQuatroFormaggi.put("name", "Quattro Formaggi"); - propsQuatroFormaggi.put("description", "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus."); - propsQuatroFormaggi.put("price", 1.4f); - propsQuatroFormaggi.put("bestBefore", "2022-01-02T03:04:05+01:00"); - - Map propsFruttiDiMare = new HashMap<>(); - propsFruttiDiMare.put("name", "Frutti di Mare"); - propsFruttiDiMare.put("description", "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce."); - propsFruttiDiMare.put("price", 2.5f); - propsFruttiDiMare.put("bestBefore", "2022-02-03T04:05:06+02:00"); - - Map propsChicken = new HashMap<>(); - propsChicken.put("name", "ChickenSoup"); - propsChicken.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - propsChicken.put("price", 2f); - propsChicken.put("bestBefore", "2022-05-06T07:08:09+05:00"); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("name", "Beautiful"); - propsBeautiful.put("description", "Putting the game of letter soups to a whole new level."); - propsBeautiful.put("price", 3f); - propsBeautiful.put("bestBefore", "2022-06-07T08:09:10+06:00"); - - Map ids = new HashMap<>(); - ids.put(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, "Pizza"); - ids.put(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, "Pizza"); - ids.put(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID, "Soup"); - ids.put(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID, "Soup"); - - WeaviateObject[] objects = Arrays.stream(tenants).flatMap(tenant -> { - WeaviateObject pizzaQuatroFormaggi = WeaviateObject.builder() - .id(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID) - .className("Pizza") - .properties(propsQuatroFormaggi) - .tenant(tenant.getName()) - .build(); - - WeaviateObject pizzaFruttiDiMare = WeaviateObject.builder() - .id(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID) - .className("Pizza") - .properties(propsFruttiDiMare) - .tenant(tenant.getName()) - .build(); - - WeaviateObject soupChicken = WeaviateObject.builder() - .id(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .className("Soup") - .properties(propsChicken) - .tenant(tenant.getName()) - .build(); - - WeaviateObject soupBeautiful = WeaviateObject.builder() - .id(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .className("Soup") - .properties(propsBeautiful) - .tenant(tenant.getName()) - .build(); - - return Stream.of(pizzaQuatroFormaggi, pizzaFruttiDiMare, soupChicken, soupBeautiful); - }).toArray(WeaviateObject[]::new); - - Result result = client.batch().objectsBatcher() - .withObjects(objects) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(4 * tenants.length); - - Map> grouped = Arrays.stream(result.getResult()) - .collect(Collectors.groupingBy(ObjectGetResponse::getTenant)); - Arrays.stream(tenants).forEach(tenant -> { - assertThat(grouped.get(tenant.getName())).isNotNull() - .hasSize(4) - .extracting(ObjectGetResponse::getId) - .containsExactlyInAnyOrderElementsOf(ids.keySet()); - - grouped.get(tenant.getName()).forEach(item -> - assertThat(item).isNotNull() - .returns(tenant.getName(), ObjectGetResponse::getTenant) - .extracting(ObjectGetResponse::getResult) - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - ); - }); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - ids.forEach((id, className) -> - assertMT.objectExists(className, id, tenant.getName()) - ) - ); - } - - @Test - public void shouldNotCreateObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createTenantsSoup(client, tenants); - - Map propsQuatroFormaggi = new HashMap<>(); - propsQuatroFormaggi.put("name", "Quattro Formaggi"); - propsQuatroFormaggi.put("description", "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus."); - propsQuatroFormaggi.put("price", 1.4f); - propsQuatroFormaggi.put("bestBefore", "2022-01-02T03:04:05+01:00"); - - Map propsFruttiDiMare = new HashMap<>(); - propsFruttiDiMare.put("name", "Frutti di Mare"); - propsFruttiDiMare.put("description", "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce."); - propsFruttiDiMare.put("price", 2.5f); - propsFruttiDiMare.put("bestBefore", "2022-02-03T04:05:06+02:00"); - - Map propsChicken = new HashMap<>(); - propsChicken.put("name", "ChickenSoup"); - propsChicken.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - propsChicken.put("price", 2f); - propsChicken.put("bestBefore", "2022-05-06T07:08:09+05:00"); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("name", "Beautiful"); - propsBeautiful.put("description", "Putting the game of letter soups to a whole new level."); - propsBeautiful.put("price", 3f); - propsBeautiful.put("bestBefore", "2022-06-07T08:09:10+06:00"); - - Map ids = new HashMap<>(); - ids.put(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, "Pizza"); - ids.put(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, "Pizza"); - ids.put(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID, "Soup"); - ids.put(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID, "Soup"); - - WeaviateObject pizzaQuatroFormaggi = WeaviateObject.builder() - .id(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID) - .className("Pizza") - .properties(propsQuatroFormaggi) - .build(); - - WeaviateObject pizzaFruttiDiMare = WeaviateObject.builder() - .id(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID) - .className("Pizza") - .properties(propsFruttiDiMare) - .build(); - - WeaviateObject soupChicken = WeaviateObject.builder() - .id(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .className("Soup") - .properties(propsChicken) - .build(); - - WeaviateObject soupBeautiful = WeaviateObject.builder() - .id(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .className("Soup") - .properties(propsBeautiful) - .build(); - - Result result = client.batch().objectsBatcher() - .withObjects(pizzaQuatroFormaggi, pizzaFruttiDiMare, soupChicken, soupBeautiful) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(4) - .extracting(o -> ((ObjectGetResponse) o).getId()) - .containsExactlyInAnyOrderElementsOf(ids.keySet()); - - Arrays.stream(result.getResult()).forEach(ogr -> - assertThat(ogr).isNotNull() - .returns(null, ObjectGetResponse::getTenant) - .extracting(ObjectGetResponse::getResult) - .returns(ObjectGetResponseStatus.FAILED, ObjectsGetResponseAO2Result::getStatus) - ); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - ids.forEach((id, className) -> - assertMT.objectDoesNotExist(className, id, tenant.getName()) - ) - ); - } - - @Test - public void shouldDeleteObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> { - Result result = client.batch().objectsBatchDeleter() - .withClassName(className) - .withTenant(tenant.getName()) - .withWhere(WhereFilter.builder() - .operator(Operator.Like) - .path(new String[]{"_id"}) - .valueText("*") - .build()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(BatchDeleteResponse::getResults) - .returns((long) ids.size(), BatchDeleteResponse.Results::getMatches) - .returns((long) ids.size(), BatchDeleteResponse.Results::getSuccessful); - - // verify deleted - ids.forEach(id -> assertMT.objectDoesNotExist(className, id, tenant.getName())); - }) - ); - } - - @Test - public void shouldNotDeleteObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> { - Result result = client.batch().objectsBatchDeleter() - .withClassName(className) - .withWhere(WhereFilter.builder() - .operator(Operator.Like) - .path(new String[]{"_id"}) - .valueText("*") - .build()) - .run(); - - assertMT.error(result, null, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - - Arrays.stream(tenants).forEach(tenant -> - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> - ids.forEach(id -> assertMT.objectExists(className, id, tenant.getName())) - ) - ); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateMockServerTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateMockServerTest.java deleted file mode 100644 index fc3645806..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateMockServerTest.java +++ /dev/null @@ -1,243 +0,0 @@ -package io.weaviate.integration.client.batch; - -import static org.mockserver.integration.ClientAndServer.startClientAndServer; -import static org.mockserver.model.HttpRequest.request; -import static org.mockserver.model.HttpResponse.response; - -import java.util.function.Consumer; -import java.util.function.Supplier; - -import org.junit.After; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockserver.client.MockServerClient; -import org.mockserver.integration.ClientAndServer; -import org.mockserver.model.Delay; -import org.mockserver.verify.VerificationTimes; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.integration.tests.batch.BatchReferencesMockServerTestSuite; - -@Ignore // Blocking 5.1.0-alpha1 release, will be revisited before 5.1.0. -@RunWith(JParamsTestRunner.class) -public class ClientBatchReferencesCreateMockServerTest { - - private WeaviateClient client; - private ClientAndServer mockServer; - private MockServerClient mockServerClient; - - private static final String MOCK_SERVER_HOST = "localhost"; - private static final int MOCK_SERVER_PORT = 8999; - - private static final BatchReference refPizzaToSoup = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_PIZZA) - .to(BatchReferencesMockServerTestSuite.TO_SOUP) - .build(); - private static final BatchReference refSoupToPizza = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_SOUP) - .to(BatchReferencesMockServerTestSuite.TO_PIZZA) - .build(); - private static final BatchReference refPizzaToPizza = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_PIZZA) - .to(BatchReferencesMockServerTestSuite.TO_PIZZA) - .build(); - private static final BatchReference refSoupToSoup = BatchReference.builder() - .from(BatchReferencesMockServerTestSuite.FROM_SOUP) - .to(BatchReferencesMockServerTestSuite.TO_SOUP) - .build(); - - @Before - public void before() { - mockServer = startClientAndServer(MOCK_SERVER_PORT); - mockServerClient = new MockServerClient(MOCK_SERVER_HOST, MOCK_SERVER_PORT); - - mockServerClient.when( - request().withMethod("GET").withPath("/v1/meta")).respond( - response().withStatusCode(200).withBody(metaBody())); - - Config config = new Config("http", MOCK_SERVER_HOST + ":" + MOCK_SERVER_PORT, null, 1, 1, 1); - client = new WeaviateClient(config); - } - - @After - public void stopMockServer() { - mockServer.stop(); - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToConnectionIssue") - public void shouldNotCreateBatchReferencesDueToConnectionIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - long execMin, long execMax) { - // stop server to simulate connection issues - mockServer.stop(); - - Supplier> supplierReferencesBatcher = () -> client.batch() - .referencesBatcher(batchRetriesConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run(); - - BatchReferencesMockServerTestSuite.testNotCreateBatchReferencesDueToConnectionIssue(supplierReferencesBatcher, - execMin, execMax); - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToConnectionIssue") - public void shouldNotCreateAutoBatchReferencesDueToConnectionIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - long execMin, long execMax) { - // stop server to simulate connection issues - mockServer.stop(); - - Consumer>> supplierReferencesBatcher = callback -> { - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .poolSize(1) - .callback(callback) - .build(); - - client.batch().referencesAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .flush(); - }; - - BatchReferencesMockServerTestSuite.testNotCreateAutoBatchReferencesDueToConnectionIssue(supplierReferencesBatcher, - execMin, execMax); - } - - public static Object[][] provideForNotCreateBatchReferencesDueToConnectionIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(0) - .build(), - 0, 100 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(1) - .build(), - 200, 300 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(2) - .build(), - 600, 700 - }, - new Object[] { - // final response should be available after 1 retry (200 + 400 + 600 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxConnectionRetries(3) - .build(), - 1200, 1300 - }, - }; - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToTimeoutIssue") - public void shouldNotCreateBatchReferencesDueToTimeoutIssue(ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/references")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - - Supplier> supplierReferencesBatcher = () -> client.batch() - .referencesBatcher(batchRetriesConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .run(); - Consumer assertBatchCallsTimes = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/references"), - VerificationTimes.exactly(count)); - - BatchReferencesMockServerTestSuite.testNotCreateBatchReferencesDueToTimeoutIssue(supplierReferencesBatcher, - assertBatchCallsTimes, expectedBatchCalls, "Read timed out"); - } - - @Test - @DataMethod(source = ClientBatchReferencesCreateMockServerTest.class, method = "provideForNotCreateBatchReferencesDueToTimeoutIssue") - public void shouldNotCreateAutoBatchReferencesDueToTimeoutIssue( - ReferencesBatcher.BatchRetriesConfig batchRetriesConfig, - int expectedBatchCalls) { - // given client times out after 1s - - mockServerClient.when( - request().withMethod("POST").withPath("/v1/batch/references")).respond( - response().withDelay(Delay.seconds(2)).withStatusCode(200)); - - Consumer>> supplierReferencesBatcher = callback -> { - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .poolSize(1) - .callback(callback) - .build(); - - client.batch().referencesAutoBatcher(batchRetriesConfig, autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .flush(); - }; - Consumer assertBatchCallsTimes = count -> mockServerClient.verify( - request().withMethod("POST").withPath("/v1/batch/references"), - VerificationTimes.exactly(count)); - - BatchReferencesMockServerTestSuite.testNotCreateAutoBatchReferencesDueToTimeoutIssue(supplierReferencesBatcher, - assertBatchCallsTimes, expectedBatchCalls, "Read timed out"); - } - - public static Object[][] provideForNotCreateBatchReferencesDueToTimeoutIssue() { - return new Object[][] { - new Object[] { - // final response should be available immediately - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(0) - .build(), - 1 - }, - new Object[] { - // final response should be available after 1 retry (200 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(1) - .build(), - 2 - }, - new Object[] { - // final response should be available after 2 retries (200 + 400 ms) - ReferencesBatcher.BatchRetriesConfig.defaultConfig() - .retriesIntervalMs(200) - .maxTimeoutRetries(2) - .build(), - 3 - }, - }; - } - - private String metaBody() { - return String.format("{\n" + - " \"hostname\": \"http://[::]:%s\",\n" + - " \"modules\": {},\n" + - " \"version\": \"%s\"\n" + - "}", MOCK_SERVER_PORT, "1.17.999-mock-server-version"); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateTest.java deleted file mode 100644 index 17405e207..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesCreateTest.java +++ /dev/null @@ -1,123 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.api.ReferencesBatcher; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.batch.BatchReferencesTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.List; -import java.util.function.Consumer; -import java.util.function.Supplier; - -public class ClientBatchReferencesCreateTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateBatchReferences() { - Supplier> supplierReferencesBatcherResult = () -> { - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", BatchReferencesTestSuite.SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", BatchReferencesTestSuite.SOUP_ID); - BatchReference refPizzaToSoup = BatchReference.builder().from(fromPizza).to(toSoup).build(); - BatchReference refSoupToPizza = BatchReference.builder().from(fromSoup).to(toPizza).build(); - BatchReference refPizzaToPizza = BatchReference.builder().from(fromPizza).to(toPizza).build(); - BatchReference refSoupToSoup = BatchReference.builder().from(fromSoup).to(toSoup).build(); - - return client.batch().referencesBatcher() - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - }; - - BatchReferencesTestSuite.testCreateBatchReferences(supplierReferencesBatcherResult, - supplierObjectsBatcher(), supplierGetterPizzaResult(), supplierGetterSoupResult()); - } - - @Test - public void shouldCreateAutoBatchReferences() { - Consumer>> supplierReferencesBatcherResult = callback -> { - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", BatchReferencesTestSuite.SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", BatchReferencesTestSuite.PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", BatchReferencesTestSuite.SOUP_ID); - BatchReference refPizzaToSoup = BatchReference.builder().from(fromPizza).to(toSoup).build(); - BatchReference refSoupToPizza = BatchReference.builder().from(fromSoup).to(toPizza).build(); - BatchReference refPizzaToPizza = BatchReference.builder().from(fromPizza).to(toPizza).build(); - BatchReference refSoupToSoup = BatchReference.builder().from(fromSoup).to(toSoup).build(); - - ReferencesBatcher.AutoBatchConfig autoBatchConfig = ReferencesBatcher.AutoBatchConfig.defaultConfig() - .batchSize(2) - .callback(callback) - .build(); - - client.batch().referencesAutoBatcher(autoBatchConfig) - .withReferences(refPizzaToSoup, refSoupToPizza, refPizzaToPizza, refSoupToSoup) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - }; - - BatchReferencesTestSuite.testCreateAutoBatchReferences(supplierReferencesBatcherResult, - supplierObjectsBatcher(), supplierGetterPizzaResult(), supplierGetterSoupResult()); - } - - private Supplier> supplierObjectsBatcher() { - return () -> client.batch().objectsBatcher() - .withObjects(new WeaviateObject[]{ - WeaviateObject.builder() - .id(BatchReferencesTestSuite.PIZZA_ID) - .className("Pizza") - .properties(BatchReferencesTestSuite.PIZZA_PROPS) - .build(), - WeaviateObject.builder() - .id(BatchReferencesTestSuite.SOUP_ID) - .className("Soup") - .properties(BatchReferencesTestSuite.SOUP_PROPS) - .build() - }) - .run(); - } - - private Supplier>> supplierGetterPizzaResult() { - return () -> client.data().objectsGetter() - .withID(BatchReferencesTestSuite.PIZZA_ID) - .withClassName("Pizza") - .run(); - } - - private Supplier>> supplierGetterSoupResult() { - return () -> client.data().objectsGetter() - .withID(BatchReferencesTestSuite.SOUP_ID) - .withClassName("Soup") - .run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesMultiTenancyTest.java deleted file mode 100644 index f384709c3..000000000 --- a/src/test/java/io/weaviate/integration/client/batch/ClientBatchReferencesMultiTenancyTest.java +++ /dev/null @@ -1,414 +0,0 @@ -package io.weaviate.integration.client.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.BatchReferenceResponseAO1Result; -import io.weaviate.client.v1.batch.model.BatchReferenceResponseStatus; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientBatchReferencesMultiTenancyTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldCreateReferencesBetweenMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - - BatchReference[] references = Arrays.stream(tenants).flatMap(tenant -> - soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withTenant(tenant.getName()) - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(tenants.length * pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.SUCCESS, BatchReferenceResponseAO1Result::getStatus) - ); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldNotCreateReferencesBetweenMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - - BatchReference[] references = soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> { - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.FAILED, BatchReferenceResponseAO1Result::getStatus) - .extracting(BatchReferenceResponseAO1Result::getErrors) - .extracting(BatchReferenceResponseAO1Result.ErrorResponse::getError).asList() - .first() - .extracting(i -> ((BatchReferenceResponseAO1Result.ErrorItem) i).getMessage()).asString() - .contains("has multi-tenancy enabled, but request was without tenant"); - }); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }) - ); - } - - @Test - public void shouldCreateReferencesBetweenMTAndNonMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - - BatchReference[] references = Arrays.stream(tenants).flatMap(tenant -> - soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withTenant(tenant.getName()) - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(tenants.length * pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.SUCCESS, BatchReferenceResponseAO1Result::getStatus) - ); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldNotCreateReferencesBetweenMTAndNonMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - - BatchReference[] references = soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> { - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.FAILED, BatchReferenceResponseAO1Result::getStatus) - .extracting(BatchReferenceResponseAO1Result::getErrors) - .extracting(BatchReferenceResponseAO1Result.ErrorResponse::getError).asList() - .first() - .extracting(i -> ((BatchReferenceResponseAO1Result.ErrorItem) i).getMessage()).asString() - .contains("has multi-tenancy enabled, but request was without tenant"); - }); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }) - ); - } - - @Test - public void shouldNotCreateReferencesBetweenNonMTAndMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoup(client); - testGenerics.createDataSoup(client); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - - BatchReference[] references = Arrays.stream(tenants).flatMap(tenant -> - soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withTenant(tenant.getName()) - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(tenants.length * pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> { - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.FAILED, BatchReferenceResponseAO1Result::getStatus) - .extracting(BatchReferenceResponseAO1Result::getErrors) - .extracting(BatchReferenceResponseAO1Result.ErrorResponse::getError).asList() - .first() - .extracting(i -> ((BatchReferenceResponseAO1Result.ErrorItem) i).getMessage()).asString() - .contains("cannot reference a multi-tenant enabled class from a non multi-tenant enabled class"); - }); - - // verify not created - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }); - } - - - private void createSoupToPizzaRefProp() { - Result refPropResult = client.schema().propertyCreator() - .withClassName("Soup") - .withProperty(Property.builder() - .name("relatedToPizza") - .dataType(Collections.singletonList("Pizza")) - .build()) - .run(); - - assertThat(refPropResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } -} diff --git a/src/test/java/io/weaviate/integration/client/classifications/ClientClassificationsTest.java b/src/test/java/io/weaviate/integration/client/classifications/ClientClassificationsTest.java deleted file mode 100644 index f29110727..000000000 --- a/src/test/java/io/weaviate/integration/client/classifications/ClientClassificationsTest.java +++ /dev/null @@ -1,80 +0,0 @@ -package io.weaviate.integration.client.classifications; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.classifications.model.Classification; -import io.weaviate.client.v1.classifications.model.ClassificationType; -import io.weaviate.client.v1.classifications.model.ParamsKNN; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.classifications.ClassificationsTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.function.Function; -import java.util.function.Supplier; - -public class ClientClassificationsTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testClassificationScheduler() { - String[] classifyProperties = new String[]{"tagged"}; - String[] basedOnProperties = new String[]{"description"}; - - Supplier> resultSupplier = () -> client.classifications().scheduler() - .withType(ClassificationType.Contextual) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - .run(); - Supplier> resultSupplierComplete = () -> client.classifications().scheduler() - .withType(ClassificationType.Contextual) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - .withWaitForCompletion() - .run(); - - ClassificationsTestSuite.testScheduler(resultSupplier, resultSupplierComplete, testGenerics, client); - } - - @Test - public void testClassificationGetter() { - String[] classifyProperties = new String[]{"tagged"}; - String[] basedOnProperties = new String[]{"description"}; - ParamsKNN paramsKNN = ParamsKNN.builder().k(3).build(); - - Supplier> resultSupplierScheduler = () -> client.classifications().scheduler() - .withType(ClassificationType.KNN) - .withClassName("Pizza") - .withClassifyProperties(classifyProperties) - .withBasedOnProperties(basedOnProperties) - .withSettings(paramsKNN) - .run(); - Function> resultSupplierGetter = (String id) -> client.classifications().getter() - .withID(id) - .run(); - - ClassificationsTestSuite.testGetter(resultSupplierScheduler, resultSupplierGetter, testGenerics, client); - } -} diff --git a/src/test/java/io/weaviate/integration/client/cluster/ClientClusterMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/cluster/ClientClusterMultiTenancyTest.java deleted file mode 100644 index 814f93ab5..000000000 --- a/src/test/java/io/weaviate/integration/client/cluster/ClientClusterMultiTenancyTest.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.integration.client.cluster; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.cluster.ClusterMultiTenancyTestSuite; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import java.util.function.Supplier; - -public class ClientClusterMultiTenancyTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldGetNodeStatusPerClass() throws InterruptedException { - Supplier> resultSupplierAll = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .run(); - Supplier> resultSupplierPizza = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Pizza") - .run(); - Supplier> resultSupplierSoup = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Soup") - .run(); - - ClusterMultiTenancyTestSuite.testMultiTenancyDataPerClassOutputVerbose(resultSupplierAll, resultSupplierPizza, resultSupplierSoup, - testGenerics, client); - } -} diff --git a/src/test/java/io/weaviate/integration/client/cluster/ClientClusterTest.java b/src/test/java/io/weaviate/integration/client/cluster/ClientClusterTest.java deleted file mode 100644 index 77600f321..000000000 --- a/src/test/java/io/weaviate/integration/client/cluster/ClientClusterTest.java +++ /dev/null @@ -1,81 +0,0 @@ -package io.weaviate.integration.client.cluster; - -import java.util.function.Supplier; - -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.cluster.ClusterTestSuite; - -public class ClientClusterTest { - - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testClusterNodesEndpointWithoutDataWithOutputVerbose() { - Supplier> resultSupplier = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .run(); - - ClusterTestSuite.testNoDataOutputVerbose(resultSupplier); - } - - @Test - public void testClusterNodesEndpointWithDataWithOutputVerbose() throws InterruptedException { - Supplier> resultSupplier = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .run(); - - ClusterTestSuite.testDataOutputVerbose(resultSupplier, testGenerics, client); - } - - @Test - public void shouldGetNodeStatusPerClassWithOutputVerbose() throws InterruptedException { - Supplier> resultSupplierAll = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .run(); - Supplier> resultSupplierPizza = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Pizza") - .run(); - Supplier> resultSupplierSoup = () -> client.cluster().nodesStatusGetter() - .withOutput(NodeStatusOutput.VERBOSE) - .withClassName("Soup") - .run(); - - ClusterTestSuite.testDataPerClassOutputVerbose(resultSupplierAll, resultSupplierPizza, resultSupplierSoup, - testGenerics, client); - } - - @Test - public void testClusterNodesEndpointWithOutputMinimalImplicit() { - Supplier> resultSupplier = () -> client.cluster().nodesStatusGetter() - .run(); - - ClusterTestSuite.testNoDataOutputMinimalImplicit(resultSupplier); - } -} diff --git a/src/test/java/io/weaviate/integration/client/cluster/ClientReplicateTest.java b/src/test/java/io/weaviate/integration/client/cluster/ClientReplicateTest.java deleted file mode 100644 index 7aef20940..000000000 --- a/src/test/java/io/weaviate/integration/client/cluster/ClientReplicateTest.java +++ /dev/null @@ -1,211 +0,0 @@ -package io.weaviate.integration.client.cluster; - -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.function.Supplier; - -import org.assertj.core.api.Assertions; -import org.assertj.core.util.Arrays; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.cluster.api.replication.Replication; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperation; -import io.weaviate.client.v1.cluster.api.replication.model.ReplicateOperationState; -import io.weaviate.client.v1.cluster.model.NodeStatusOutput; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.client.v1.cluster.model.ReplicationType; -import io.weaviate.client.v1.cluster.model.ShardReplicas; -import io.weaviate.client.v1.cluster.model.ShardingState; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerComposeCluster; - -public class ClientReplicateTest { - @ClassRule - public static WeaviateDockerComposeCluster cluster = new WeaviateDockerComposeCluster(); - - private static WeaviateClient client; - - @Before - public void before() { - Config config = new Config("http", cluster.getHttpHost0Address()); - client = new WeaviateClient(config); - } - - private static final String CLASSNAME = "ShardDweller"; - - @After - public void afterEach() { - client.schema().classDeleter().withClassName(CLASSNAME).run(); - } - - @Test - public void testQueryShardingState() { - // Arrange - Boolean created = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(CLASSNAME).build()) - .run().getResult(); - assumeTrue(created, "created test collection"); - - NodesStatusResponse nodes = client.cluster().nodesStatusGetter() - .withClassName(CLASSNAME) - .withOutput(NodeStatusOutput.VERBOSE) - .run().getResult(); - - assumeTrue(nodes != null, "nodes status result is not null"); - assumeTrue(!Arrays.isArrayEmpty(nodes.getNodes()), "there're 1+ nodes in the cluster"); - String wantShard = nodes.getNodes()[0].getShards()[0].getName(); - - ShardingState shardingState; - - // Act: query by collection name - shardingState = client.cluster().shardingStateQuerier() - .withClassName(CLASSNAME) - .run().getResult(); - Assertions.assertThat(shardingState.getShards()) - .as("shard present in the sharding state output (by collection)") - .extracting(ShardReplicas::getName).contains(wantShard); - - // Act: query by collection + shard name - shardingState = client.cluster().shardingStateQuerier() - .withClassName(CLASSNAME) - .withShard(wantShard) - .run().getResult(); - Assertions.assertThat(shardingState.getShards()) - .as("shard present in the sharding state output (by collection+shard)") - .extracting(ShardReplicas::getName).contains(wantShard); - - ShardingState inexistent; - // Act: query inexistent - inexistent = client.cluster().shardingStateQuerier() - .withClassName("Unknown") - .run().getResult(); - Assertions.assertThat(inexistent).isNull(); - } - - @Test - /** - * This test starts a replication operation between two nodes, - * queries for its status, then cancels the replication and eventually deletes - * it. - * - * Note that assertions that use {@link #eventually} helper may be flaky. - */ - public void testReplicateLifecycle() { - // Arrange - Boolean created = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(CLASSNAME).build()) - .run().getResult(); - assumeTrue(created, "created test collection"); - - NodesStatusResponse nodes = client.cluster().nodesStatusGetter() - .withClassName(CLASSNAME) - .withOutput(NodeStatusOutput.VERBOSE) - .run().getResult(); - - assumeTrue(nodes != null, "nodes status result is not null"); - assumeTrue(nodes.getNodes().length >= 2, "there're 2+ nodes in the cluster"); - - String srcNode = nodes.getNodes()[0].getName(); - String tgtNode = nodes.getNodes()[1].getName(); - String wantShard = nodes.getNodes()[0].getShards()[0].getName(); - - deleteAllReplications(5); - - // Act: kick-off replication - String uuid = client.cluster().replicator() - .withClassName(CLASSNAME) - .withShard(wantShard) - .withSourceNode(srcNode) - .withTargetNode(tgtNode) - .run().getResult(); - assumeTrue(uuid != null, "replication started with valid uuid"); - - // Act: get status - ReplicateOperation status_1 = client.cluster().replication().getter() - .withUuid(uuid).run().getResult(); - - Assertions.assertThat(status_1).isNotNull() - .as("expected replication status") - .returns(CLASSNAME, ReplicateOperation::getClassName) - .returns(wantShard, ReplicateOperation::getShard) - .returns(srcNode, ReplicateOperation::getSourceNode) - .returns(tgtNode, ReplicateOperation::getTargetNode) - .returns(ReplicationType.COPY, ReplicateOperation::getTransferType) - .returns(null, ReplicateOperation::getStatusHistory) - .extracting(ReplicateOperation::getStatus).isNotNull(); - - // Act: get status with history - ReplicateOperation status_2 = client.cluster().replication().getter() - .withUuid(uuid).withIncludeHistory(true) - .run().getResult(); - - Assertions.assertThat(status_2).isNotNull() - .as("includes replication status history") - .extracting(ReplicateOperation::getStatusHistory).isNotNull(); - - // Act: query status - List operations = client.cluster().replication().querier() - .withClassName(CLASSNAME).withShard(wantShard).withTargetNode(tgtNode) - .run().getResult(); - - Assertions.assertThat(operations).as("no. replications").hasSize(1); - - // Act: cancel - Result cancel = client.cluster().replication().canceler().withUuid(uuid).run(); - Assertions.assertThat(cancel).as("cancel error").returns(null, Result::getError); - - eventually(() -> client.cluster().replication().getter().withUuid(uuid).run().getResult() - .getStatus().getState() == ReplicateOperationState.CANCELLED, - 25, "replication was not cancelled"); - - // Act: delete - Result delete = client.cluster().replication().deleter().withUuid(uuid).run(); - Assertions.assertThat(delete).as("delete error").returns(null, Result::getError); - - eventually(() -> client.cluster().replication().allGetter().run().getResult().isEmpty(), - 15, "replication was not deleted"); - } - - private static void deleteAllReplications(int timeoutSeconds) { - Replication replication = client.cluster().replication(); - replication.allDeleter().run(); - eventually(() -> replication.allGetter().run().getResult().isEmpty(), - timeoutSeconds, - "did not delete existing replications"); - } - - private static void eventually(Supplier cond, int timeoutSeconds, String... message) { - CompletableFuture check = CompletableFuture.runAsync(() -> { - while (!Thread.currentThread().isInterrupted() && !cond.get()) { - try { - Thread.sleep(500); - } catch (InterruptedException ex) { - Thread.currentThread().interrupt(); - } - } - }); - - try { - check.get(timeoutSeconds, TimeUnit.SECONDS); - } catch (TimeoutException ex) { - check.cancel(true); - Assertions.fail(message.length >= 0 ? message[0] : null, ex); - } catch (InterruptedException ex) { - Thread.currentThread().interrupt(); - Assertions.fail(ex); - } catch (ExecutionException ex) { - throw new RuntimeException(ex); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/contextionary/ClientContextionaryTest.java b/src/test/java/io/weaviate/integration/client/contextionary/ClientContextionaryTest.java deleted file mode 100644 index 3ca0be972..000000000 --- a/src/test/java/io/weaviate/integration/client/contextionary/ClientContextionaryTest.java +++ /dev/null @@ -1,49 +0,0 @@ -package io.weaviate.integration.client.contextionary; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.contextionary.model.C11yWordsResponse; -import io.weaviate.integration.client.WeaviateDockerCompose; -import org.junit.Assert; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientContextionaryTest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - @Test - public void testContextionaryGetter() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - // when - Result pizzaHawaii = client.c11y().conceptsGetter().withConcept("pizzaHawaii").run(); - // then - Assert.assertNotNull(pizzaHawaii); - Assert.assertNotNull(pizzaHawaii.getResult()); - Assert.assertNull(pizzaHawaii.getError()); - } - - @Test - public void testContextionaryExtensionCreator() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - // when - Result extensionSuccess = client.c11y().extensionCreator() - .withConcept("xoxo").withDefinition("Hugs and kisses").withWeight(1.0f).run(); - // then - Assert.assertNotNull(extensionSuccess); - Assert.assertTrue(extensionSuccess.getResult()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/data/ClientDataMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/data/ClientDataMultiTenancyTest.java deleted file mode 100644 index b312daae4..000000000 --- a/src/test/java/io/weaviate/integration/client/data/ClientDataMultiTenancyTest.java +++ /dev/null @@ -1,804 +0,0 @@ -package io.weaviate.integration.client.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.MultiTenancyConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.AssertMultiTenancy; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientDataMultiTenancyTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - private AssertMultiTenancy assertMT; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - assertMT = new AssertMultiTenancy(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - - @Test - public void shouldCreateObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Map propsQuatroFormaggi = new HashMap<>(); - propsQuatroFormaggi.put("name", "Quattro Formaggi"); - propsQuatroFormaggi.put("description", "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus."); - propsQuatroFormaggi.put("price", 1.4f); - propsQuatroFormaggi.put("bestBefore", "2022-01-02T03:04:05+01:00"); - - Map propsFruttiDiMare = new HashMap<>(); - propsFruttiDiMare.put("name", "Frutti di Mare"); - propsFruttiDiMare.put("description", "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce."); - propsFruttiDiMare.put("price", 2.5f); - propsFruttiDiMare.put("bestBefore", "2022-02-03T04:05:06+02:00"); - - Arrays.stream(tenants).forEach(tenant -> { - Result pizzaQuatroFormaggiStatus = client.data().creator() - .withClassName("Pizza") - .withID(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID) - .withProperties(propsQuatroFormaggi) - .withTenant(tenant.getName()) - .run(); - - assertThat(pizzaQuatroFormaggiStatus).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult) - .returns(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, WeaviateObject::getId) - .returns("Pizza", WeaviateObject::getClassName) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("Quattro Formaggi", p -> p.get("name")) - .returns(1.4d, p -> p.get("price")) - .returns("Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus.", p -> p.get("description")) - .returns("2022-01-02T03:04:05+01:00", p -> p.get("bestBefore")); - - Result pizzaFruttiDiMareStatus = client.data().creator() - .withClassName("Pizza") - .withID(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID) - .withProperties(propsFruttiDiMare) - .withTenant(tenant.getName()) - .run(); - - assertThat(pizzaFruttiDiMareStatus).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult) - .returns(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, WeaviateObject::getId) - .returns("Pizza", WeaviateObject::getClassName) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("Frutti di Mare", p -> p.get("name")) - .returns(2.5d, p -> p.get("price")) - .returns("Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce.", p -> p.get("description")) - .returns("2022-02-03T04:05:06+02:00", p -> p.get("bestBefore")); - }); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - Arrays.asList( - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID - ).forEach(id -> assertMT.objectExists("Pizza", id, tenant.getName()))); - } - - @Test - public void shouldNotCreateObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Map propsQuatroFormaggi = new HashMap<>(); - propsQuatroFormaggi.put("name", "Quattro Formaggi"); - propsQuatroFormaggi.put("description", "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus."); - propsQuatroFormaggi.put("price", 1.4f); - propsQuatroFormaggi.put("bestBefore", "2022-01-02T03:04:05+01:00"); - - Map propsFruttiDiMare = new HashMap<>(); - propsFruttiDiMare.put("name", "Frutti di Mare"); - propsFruttiDiMare.put("description", "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce."); - propsFruttiDiMare.put("price", 2.5f); - propsFruttiDiMare.put("bestBefore", "2022-02-03T04:05:06+02:00"); - - Result pizzaQuatroFormaggiStatus = client.data().creator() - .withClassName("Pizza") - .withID(WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID) - .withProperties(propsQuatroFormaggi) - .run(); - - assertMT.error(pizzaQuatroFormaggiStatus, null, 422, "has multi-tenancy enabled, but request was without tenant"); - - Result pizzaFruttiDiMareStatus = client.data().creator() - .withClassName("Pizza") - .withID(WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID) - .withProperties(propsFruttiDiMare) - .run(); - - assertMT.error(pizzaFruttiDiMareStatus, null, 422, "has multi-tenancy enabled, but request was without tenant"); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - Arrays.asList( - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID - ).forEach(id -> assertMT.objectDoesNotExist("Pizza", id, tenant.getName()))); - } - - @Test - public void shouldGetObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> { - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> { - ids.forEach(id -> { - Result> getResultByClassId = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName(className) - .withID(id) - .run(); - - assertThat(getResultByClassId).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(id, WeaviateObject::getId) - .returns(className, WeaviateObject::getClassName) - .returns(tenant.getName(), WeaviateObject::getTenant); - }); - - Result> getResultByClass = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName(className) - .run(); - - assertThat(getResultByClass).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(ids.size()) - .extracting(o -> ((WeaviateObject) o).getId()) - .containsExactlyInAnyOrderElementsOf(ids); - }); - - Result> getResultAll = client.data().objectsGetter() - .withTenant(tenant.getName()) - .run(); - - assertThat(getResultAll).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(WeaviateTestGenerics.IDS_ALL.size()) - .extracting(o -> ((WeaviateObject) o).getId()) - .containsExactlyInAnyOrderElementsOf(WeaviateTestGenerics.IDS_ALL); - } - ); - } - - @Test - public void shouldNotGetObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> { - ids.forEach(id -> { - Result> getResultByClassId = client.data().objectsGetter() - .withClassName(className) - .withID(id) - .run(); - - assertMT.error(getResultByClassId, null, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - - Result> getResultByClass = client.data().objectsGetter() - .withClassName(className) - .run(); - - assertMT.error(getResultByClass, null, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - - Result> getResultAll = client.data().objectsGetter() - .run(); - - assertThat(getResultAll).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .isEmpty(); - } - - @Test - public void shouldCheckObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> - ids.forEach(id -> { - Result checkResult = client.data().checker() - .withClassName(className) - .withID(id) - .withTenant(tenant.getName()) - .run(); - - assertThat(checkResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - }) - ) - ); - } - - @Test - public void shouldNotCheckObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> - ids.forEach(id -> { - Result checkResult = client.data().checker() - .withClassName(className) - .withID(id) - .run(); - - assertThat(checkResult).isNotNull() - .returns(false, Result::getResult) - .returns(true, Result::hasErrors) - .extracting(Result::getError) - .returns(422, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .isEmpty(); - }) - ); - } - - @Test - public void shouldDeleteObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> { - int[] expectedObjectsLeft = new int[]{ids.size()}; - - ids.forEach(id -> { - Result deleteStatus = client.data().deleter() - .withTenant(tenant.getName()) - .withClassName(className) - .withID(id) - .run(); - - assertThat(deleteStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // verify deleted - assertMT.objectDoesNotExist(className, id, tenant.getName()); - assertMT.countObjects(className, tenant.getName(), --expectedObjectsLeft[0]); - }); - }) - ); - } - - @Test - public void shouldNotDeleteObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaFoodForTenants(client); - testGenerics.createTenantsFood(client, tenants); - testGenerics.createDataFoodForTenants(client, tenantNames); - - WeaviateTestGenerics.IDS_BY_CLASS.forEach((className, ids) -> - ids.forEach(id -> { - Result deleteStatus = client.data().deleter() - .withClassName(className) - .withID(id) - .run(); - - assertMT.error(deleteStatus, false, 422, "has multi-tenancy enabled, but request was without tenant"); - - // verify not deleted - Arrays.stream(tenants).forEach(tenant -> - assertMT.objectExists(className, id, tenant.getName()) - ); - }) - ); - - // verify not deleted - Arrays.stream(tenants).forEach(tenant -> - assertMT.countObjects(tenant.getName(), WeaviateTestGenerics.IDS_ALL.size()) - ); - } - - @Test - public void shouldUpdateObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - - Map propsChicken = new HashMap<>(); - propsChicken.put("name", "ChickenSoup"); - propsChicken.put("description", "updated ChickenSoup description"); - propsChicken.put("price", 1000.1f); - propsChicken.put("bestBefore", "2022-05-06T07:08:09+05:00"); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("name", "Beautiful"); - propsBeautiful.put("description", "updated Beautiful description"); - propsBeautiful.put("price", 2000.2f); - propsBeautiful.put("bestBefore", "2022-06-07T08:09:10+06:00"); - - Arrays.stream(tenants).forEach(tenant -> { - Result soupChickenStatus = client.data().updater() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .withProperties(propsChicken) - .run(); - - assertThat(soupChickenStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result soupBeautifulStatus = client.data().updater() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .withProperties(propsBeautiful) - .run(); - - assertThat(soupBeautifulStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // verify updated - Result> soupChicken = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .run(); - - assertThat(soupChicken).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns(propsChicken.get("name"), p -> p.get("name")) - .returns(propsChicken.get("description"), p -> p.get("description")) - .returns(1000.1d, p -> p.get("price")) - .returns(propsChicken.get("bestBefore"), p -> p.get("bestBefore")); - - Result> soupBeautiful = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .run(); - - assertThat(soupBeautiful).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns(propsBeautiful.get("name"), p -> p.get("name")) - .returns(propsBeautiful.get("description"), p -> p.get("description")) - .returns(2000.2d, p -> p.get("price")) - .returns(propsBeautiful.get("bestBefore"), p -> p.get("bestBefore")); - }); - } - - @Test - public void shouldNotUpdateObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - - Map propsChicken = new HashMap<>(); - propsChicken.put("name", "ChickenSoup"); - propsChicken.put("description", "updated ChickenSoup description"); - propsChicken.put("price", 1000.1f); - propsChicken.put("bestBefore", "2022-05-06T07:08:09+05:00"); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("name", "Beautiful"); - propsBeautiful.put("description", "updated Beautiful description"); - propsBeautiful.put("price", 2000.2f); - propsBeautiful.put("bestBefore", "2022-06-07T08:09:10+06:00"); - - Result soupChickenStatus = client.data().updater() - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .withProperties(propsChicken) - .run(); - - assertMT.error(soupChickenStatus, false, 422, "has multi-tenancy enabled, but request was without tenant"); - - Result soupBeautifulStatus = client.data().updater() - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .withProperties(propsBeautiful) - .run(); - - assertMT.error(soupBeautifulStatus, false, 422, "has multi-tenancy enabled, but request was without tenant"); - - // verify not updated - Arrays.stream(tenants).forEach(tenant -> { - Result> soupChicken = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .run(); - - assertThat(soupChicken).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("ChickenSoup", p -> p.get("name")) - .returns("Used by humans when their inferior genetics are attacked by microscopic organisms.", p -> p.get("description")) - .returns(2d, p -> p.get("price")) - .returns("2022-05-06T07:08:09+05:00", p -> p.get("bestBefore")); - - Result> soupBeautiful = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .run(); - - assertThat(soupBeautiful).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("Beautiful", p -> p.get("name")) - .returns("Putting the game of letter soups to a whole new level.", p -> p.get("description")) - .returns(3d, p -> p.get("price")) - .returns("2022-06-07T08:09:10+06:00", p -> p.get("bestBefore")); - }); - } - - @Test - public void shouldMergeObjects() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - - Map propsChicken = new HashMap<>(); - propsChicken.put("description", "updated ChickenSoup description"); - propsChicken.put("price", 1000.1f); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("description", "updated Beautiful description"); - propsBeautiful.put("price", 2000.2f); - - Arrays.stream(tenants).forEach(tenant -> { - Result soupChickenStatus = client.data().updater() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .withProperties(propsChicken) - .withMerge() - .run(); - - assertThat(soupChickenStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result soupBeautifulStatus = client.data().updater() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .withProperties(propsBeautiful) - .withMerge() - .run(); - - assertThat(soupBeautifulStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // verify merged - Result> soupChicken = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .run(); - - assertThat(soupChicken).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("ChickenSoup", p -> p.get("name")) - .returns(propsChicken.get("description"), p -> p.get("description")) - .returns(1000.1d, p -> p.get("price")) - .returns("2022-05-06T07:08:09+05:00", p -> p.get("bestBefore")); - - Result> soupBeautiful = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .run(); - - assertThat(soupBeautiful).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("Beautiful", p -> p.get("name")) - .returns(propsBeautiful.get("description"), p -> p.get("description")) - .returns(2000.2d, p -> p.get("price")) - .returns("2022-06-07T08:09:10+06:00", p -> p.get("bestBefore")); - }); - } - - @Test - public void shouldNotMergeObjectsWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - - Map propsChicken = new HashMap<>(); - propsChicken.put("description", "updated ChickenSoup description"); - propsChicken.put("price", 1000.1f); - - Map propsBeautiful = new HashMap<>(); - propsBeautiful.put("description", "updated Beautiful description"); - propsBeautiful.put("price", 2000.2f); - - Result soupChickenStatus = client.data().updater() - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .withProperties(propsChicken) - .withMerge() - .run(); - - assertMT.error(soupChickenStatus, false, 422, "has multi-tenancy enabled, but request was without tenant"); - - Result soupBeautifulStatus = client.data().updater() - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .withProperties(propsBeautiful) - .withMerge() - .run(); - - assertMT.error(soupBeautifulStatus, false, 422, "has multi-tenancy enabled, but request was without tenant"); - - // verify not updated - Arrays.stream(tenants).forEach(tenant -> { - Result> soupChicken = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_CHICKENSOUP_ID) - .run(); - - assertThat(soupChicken).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("ChickenSoup", p -> p.get("name")) - .returns("Used by humans when their inferior genetics are attacked by microscopic organisms.", p -> p.get("description")) - .returns(2d, p -> p.get("price")) - .returns("2022-05-06T07:08:09+05:00", p -> p.get("bestBefore")); - - Result> soupBeautiful = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(WeaviateTestGenerics.SOUP_BEAUTIFUL_ID) - .run(); - - assertThat(soupBeautiful).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> (WeaviateObject) o) - .returns(tenant.getName(), WeaviateObject::getTenant) - .extracting(WeaviateObject::getProperties) - .returns("Beautiful", p -> p.get("name")) - .returns("Putting the game of letter soups to a whole new level.", p -> p.get("description")) - .returns(3d, p -> p.get("price")) - .returns("2022-06-07T08:09:10+06:00", p -> p.get("bestBefore")); - }); - } - - @Test - public void shouldAutoCreateTenantsClassWithMultiTenancyConfig() { - String className = "MultiAutoCreateTenantClass"; - String autoCreatedTenantName = "AutoTenant"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .multiTenancyConfig(MultiTenancyConfig.builder() - .autoTenantCreation(true) - .enabled(true) - .build()) - .properties(Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus.hasErrors()).isFalse(); - assertThat(createStatus.getResult()).isTrue(); - - Result classResult = client.schema().classGetter().withClassName(className).run(); - assertThat(classResult.hasErrors()).isFalse(); - assertThat(classResult.getResult()).isNotNull() - .extracting(WeaviateClass::getMultiTenancyConfig) - .isNotNull() - .returns(true, MultiTenancyConfig::getEnabled); - - Result exists = client.schema().tenantsExists() - .withClassName(className) - .withTenant(autoCreatedTenantName) - .run(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(false, Result::getResult); - - String id = "10000000-0000-0000-0000-000000000000"; - Map properties1 = new HashMap<>(); - properties1.put("name", "Some name"); - Map properties2 = new HashMap<>(); - properties2.put("name", "Some other name"); - - WeaviateObject obj1 = WeaviateObject.builder() - .className(className) - .id(id) - .properties(properties1) - .tenant(autoCreatedTenantName) - .build(); - - WeaviateObject obj2 = WeaviateObject.builder() - .className(className) - .properties(properties2) - .tenant(autoCreatedTenantName) - .build(); - - Result run = client.batch().objectsBatcher().withObjects(obj1, obj2).run(); - - assertThat(run).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .asInstanceOf(ARRAY).hasSize(2); - - exists = client.schema().tenantsExists() - .withClassName(className) - .withTenant(autoCreatedTenantName) - .run(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result> result = client.data().objectsGetter() - .withClassName(className) - .withID(id) - .withTenant(autoCreatedTenantName) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1); - } -} diff --git a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java b/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java deleted file mode 100644 index 9bfaf74e0..000000000 --- a/src/test/java/io/weaviate/integration/client/data/ClientDataTest.java +++ /dev/null @@ -1,764 +0,0 @@ -package io.weaviate.integration.client.data; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.type; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assumptions.assumeFalse; -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.UUID; - -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.misc.model.MultiVectorConfig; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.MuveraConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.data.DataTestSuite; -import com.google.gson.GsonBuilder; - - -public class ClientDataTest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - @Test - public void testDataCreate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataCreate.objTID; - String objAID = DataTestSuite.testDataCreate.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataCreate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataCreate.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> objectsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataCreate.assertResults(objectT, objectA, objectsT, objectsA); - } - - @Test - public void testDataCreateAndRetrieveMultiVectors() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - try { - - // Arrange: Configure collection and create it - String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("regular", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexType("hnsw").build()); - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()).build()) - .vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); - assumeTrue(createResult.getResult(), "schema created successfully"); - - String id = UUID.randomUUID().toString(); - Float[][] colbertVector = - new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, - {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; - - // Act: Insert test data - Result insertResult = client.data().creator().withID(id) - .withClassName(className).withProperties(new HashMap() { - { - this.put("name", "TestObject-1"); - this.put("title", "The Lord of the Rings"); - } - }).withVectors(new HashMap() { - { - this.put("regular", colbertVector[0]); - } - }).withMultiVectors(new HashMap() { - { - this.put("colbert", colbertVector); - } - }).run(); - - // Assert: Retrieve object and check its dimensions - Result> getResult = - client.data().objectsGetter().withClassName(className).withID(id).withVector().run(); - - assertThat(getResult).isNotNull().returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null").extracting(r -> r.get(0)) - .isNotNull().as("first object").satisfies(o -> { - assertThat(o.getVectors()).as("1d-vectors").isNotEmpty().containsOnlyKeys("regular"); - - assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() - .containsOnlyKeys("colbert").satisfies(multi -> { - assertThat(multi.get("colbert")).as("colbert multivector") - .isEqualTo(colbertVector); - }); - }).as("expected object metadata"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(client); - } - } - - @Test - public void testCreateMuvera() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - try { - - // Arrange: Configure collection and create it - String className = "NamedMuvera"; - MuveraConfig muveraConfig = - MuveraConfig.builder().enabled(true).ksim(10).dprojections(16).repetitions(20).build(); - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().encoding(muveraConfig).build()) - .bq(BQConfig.builder().enabled(true).build()).build(); - - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(vectorIndexConfig).vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); - assumeTrue(createResult.getResult(), "schema created successfully"); - Result schemaResult = client.schema().getter().run(); - MuveraConfig result = schemaResult.getResult().getClasses().get(0).getVectorConfig() - .get("colbert").getVectorIndexConfig().getMultiVector().getMuveraEncoding(); - assumeTrue(result.equals(muveraConfig), "muvera config is correct"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(client); - } - } - - @Test - public void testDataCreateWithSpecialCharacters() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataCreateWithSpecialCharacters.objTID; - String name = DataTestSuite.testDataCreateWithSpecialCharacters.name; - String description = DataTestSuite.testDataCreateWithSpecialCharacters.description; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithSpecialCharacters.propertiesSchemaT(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataCreateWithSpecialCharacters.assertResults(objectT, objectsT); - } - - @Test - public void testDataGetActionsThings() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result pizzaObj1 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Margherita"); - put("description", "plain"); - } - }).run(); - Result pizzaObj2 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Pepperoni"); - put("description", "meat"); - } - }).run(); - Result soupObj1 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Chicken"); - put("description", "plain"); - } - }).run(); - Result soupObj2 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Tofu"); - put("description", "vegetarian"); - } - }).run(); - Result> objects = client.data().objectsGetter().run(); - Result> objects1 = - client.data().objectsGetter().withClassName("Pizza").withLimit(1).run(); - assertNull(objects1.getError()); - assertEquals(1l, objects1.getResult().size()); - String firstPizzaID = objects1.getResult().get(0).getId(); - Result> afterFirstPizzaObjects = client.data().objectsGetter() - .withClassName("Pizza").withAfter(firstPizzaID).withLimit(1).run(); - - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataGetActionsThings.assertResults(pizzaObj1, pizzaObj2, soupObj1, soupObj2, - objects, afterFirstPizzaObjects); - } - - @Test - public void testDataGetWithAdditional() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataGetWithAdditional.objTID; - String objAID = DataTestSuite.testDataGetWithAdditional.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataGetWithAdditional.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataGetWithAdditional.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> objectsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - Result> objsAdditionalT = - client.data().objectsGetter().withID(objTID).withClassName("Pizza") - .withAdditional("classification").withAdditional("nearestNeighbors").withVector().run(); - Result> objsAdditionalA = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withAdditional("classification").withAdditional("nearestNeighbors") - .withAdditional("interpretation").withVector().run(); - Result> objsAdditionalA1 = - client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - Result> objsAdditionalA2 = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withAdditional("interpretation").run(); - Result> objsAdditionalAError = client.data().objectsGetter().withID(objAID) - .withClassName("Soup").withAdditional("featureProjection").run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataGetWithAdditional.assertResults(objectT, objectA, objectsT, objectsA, - objsAdditionalT, objsAdditionalA, objsAdditionalA1, objsAdditionalA2, objsAdditionalAError); - } - - @Test - public void testDataDelete() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataDelete.objTID; - String objAID = DataTestSuite.testDataDelete.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataDelete.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataDelete.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - Result deleteObjT = client.data().deleter().withClassName("Pizza").withID(objTID) - .withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result> objTlist = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result deleteObjA = client.data().deleter().withClassName("Soup").withID(objAID) - .withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result> objAlist = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataDelete.assertResults(objectT, objectA, deleteObjT, objTlist, deleteObjA, - objAlist); - } - - @Test - public void testDataUpdate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataUpdate.objTID; - String objAID = DataTestSuite.testDataUpdate.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataUpdate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataUpdate.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - Result updateObjectT = client.data().updater().withClassName("Pizza").withID(objTID) - .withProperties(new HashMap() { - { - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - } - }).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result updateObjectA = client.data().updater().withClassName("Soup").withID(objAID) - .withProperties(new HashMap() { - { - put("name", "ChickenSoup"); - put("description", - "Used by humans when their inferior genetics are attacked by microscopic organisms."); - } - }).withConsistencyLevel(ConsistencyLevel.QUORUM).run(); - Result> updatedObjsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> updatedObjsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataUpdate.assertResults(objectT, objectA, updateObjectT, updateObjectA, - updatedObjsT, updatedObjsA); - } - - @Test - public void testDataUpdateMultiVectors() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - try { - // Arrange: Configure collection and create it - String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder().className(className) - .properties(Arrays.asList(Property.builder().name("name") - .dataType(Collections.singletonList(DataType.TEXT)).build())) - .vectorConfig(new HashMap() { - { - this.put("colbert", - WeaviateClass.VectorConfig.builder().vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }).vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()).build()) - .vectorIndexType("hnsw").build()); - } - }).build(); - - Result createResult = client.schema().classCreator().withClass(weaviateClass).run(); - assumeTrue(createResult.getResult(), "schema created successfully"); - - String id = UUID.randomUUID().toString(); - Float[][] colbertVector = - new Float[][] {{0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f}, - {0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f},}; - - Result insertResult = client.data().creator().withID(id) - .withClassName(className).withProperties(new HashMap() { - { - this.put("name", "TestObject-1"); - } - }).withMultiVectors(new HashMap() { - { - this.put("colbert", colbertVector); - } - }).run(); - assumeFalse(insertResult.hasErrors(), "test data inserted successfully"); - - // Act: Update data - Float[][] newVector = Arrays.stream(colbertVector) - .map(inner -> Arrays.stream(inner).map(v -> 5 * v).toArray(Float[]::new)) - .toArray(Float[][]::new); - Result updateResult = client.data().updater().withID(id).withClassName(className) - .withMultiVectors(new HashMap() { - { - this.put("colbert", newVector); - } - }).run(); - assertNull("successfully updated metadata", updateResult.getError()); - - // Assert: Retrieve object and check metadata - Result> getResult = - client.data().objectsGetter().withClassName(className).withID(id).withVector().run(); - - assertThat(getResult).isNotNull().returns(null, Result::getError).as("get object error") - .extracting(Result::getResult).isNotNull().as("result not null").extracting(r -> r.get(0)) - .isNotNull().as("first object").satisfies(o -> { - assertThat(o.getMultiVectors()).as("multi-vectors").isNotEmpty() - .containsOnlyKeys("colbert").satisfies(multi -> { - assertThat(multi.get("colbert")).as("colbert multivector").isEqualTo(newVector); - }); - }).as("expected updated object metadata"); - } finally { - new WeaviateTestGenerics().cleanupWeaviate(client); - } - } - - @Test - public void testDataMerge() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataMerge.objTID; - String objAID = DataTestSuite.testDataMerge.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataMerge.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataMerge.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - Result mergeObjectT = client.data().updater().withClassName("Pizza").withID(objTID) - .withProperties(new HashMap() { - { - put("description", "Universally accepted to be the best pizza ever created."); - } - }).withMerge().run(); - Result mergeObjectA = client.data().updater().withClassName("Soup").withID(objAID) - .withProperties(new HashMap() { - { - put("description", - "Used by humans when their inferior genetics are attacked by microscopic organisms."); - } - }).withMerge().run(); - Result> mergedObjsT = - client.data().objectsGetter().withClassName("Pizza").withID(objTID).run(); - Result> mergeddObjsA = - client.data().objectsGetter().withClassName("Soup").withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataMerge.assertResults(objectT, objectA, mergeObjectT, mergeObjectA, - mergedObjsT, mergeddObjsA); - } - - @Test - public void testDataValidate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataValidate.objTID; - String objAID = DataTestSuite.testDataValidate.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataValidate.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataValidate.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result validateObjT = client.data().validator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result validateObjA = client.data().validator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - propertiesSchemaT.put("test", "not existing property"); - Result validateObjT1 = client.data().validator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - propertiesSchemaA.put("test", "not existing property"); - Result validateObjA1 = client.data().validator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataValidate.assertResults(validateObjT, validateObjA, validateObjT1, - validateObjA1); - } - - @Test - public void testDataGetWithAdditionalError() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testDataGetWithAdditionalError.objTID; - String objAID = DataTestSuite.testDataGetWithAdditionalError.objAID; - Map propertiesSchemaT = - DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testDataGetWithAdditionalError.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - Result> objsAdditionalT = client.data().objectsGetter().withID(objTID) - .withClassName("Pizza").withAdditional("featureProjection").withVector().run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataGetWithAdditionalError.assertResults(objectT, objectA, objsAdditionalT); - } - - @Test - public void testDataCreateWithArrayType() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateClass clazz = DataTestSuite.testDataCreateWithArrayType.clazz; - String objTID = DataTestSuite.testDataCreateWithArrayType.objTID; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithArrayType.propertiesSchemaT(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator().withClassName("ClassArrays") - .withID(objTID).withProperties(propertiesSchemaT).run(); - Result> objectsT = - client.data().objectsGetter().withClassName("ClassArrays").withID(objTID).run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - DataTestSuite.testDataCreateWithArrayType.assertResults(createStatus, schemaAfterCreate, - objectT, objectsT, deleteStatus, schemaAfterDelete); - } - - @Test - public void testDataGetWithVector() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateClass clazz = DataTestSuite.testDataGetWithVector.clazz; - String objTID = DataTestSuite.testDataGetWithVector.objTID; - Map propertiesSchemaT = DataTestSuite.testDataGetWithVector.propertiesSchemaT(); - Float[] vectorObjT = DataTestSuite.testDataGetWithVector.vectorObjT; - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator().withClassName("ClassCustomVector") - .withID(objTID).withVector(vectorObjT).withProperties(propertiesSchemaT).run(); - Result> objT = client.data().objectsGetter() - .withClassName("ClassCustomVector").withID(objTID).withVector().run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - DataTestSuite.testDataGetWithVector.assertResults(createStatus, schemaAfterCreate, objectT, - objT, deleteStatus, schemaAfterDelete); - } - - @Test - public void testObjectCheck() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = DataTestSuite.testObjectCheck.objTID; - String objAID = DataTestSuite.testObjectCheck.objAID; - String nonExistentObjectID = DataTestSuite.testObjectCheck.nonExistentObjectID; - Map propertiesSchemaT = - DataTestSuite.testObjectCheck.propertiesSchemaT(); - Map propertiesSchemaA = - DataTestSuite.testObjectCheck.propertiesSchemaA(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result objectT = client.data().creator().withClassName("Pizza").withID(objTID) - .withProperties(propertiesSchemaT).run(); - Result objectA = client.data().creator().withClassName("Soup").withID(objAID) - .withProperties(propertiesSchemaA).run(); - // check object existence - Result checkObjT = client.data().checker().withClassName("Pizza").withID(objTID).run(); - Result checkObjA = client.data().checker().withClassName("Soup").withID(objAID).run(); - Result> objA = - client.data().objectsGetter().withID(objAID).withClassName("Soup").withVector().run(); - Result> objT = - client.data().objectsGetter().withID(objTID).withClassName("Pizza").withVector().run(); - Result checkNonexistentObject = - client.data().checker().withClassName("Pizza").withID(nonExistentObjectID).run(); - // delete all objects from Weaviate - Result deleteStatus = client.schema().allDeleter().run(); - // check object's existence status after clean up - Result checkObjTAfterDelete = - client.data().checker().withClassName("Pizza").withID(objTID).run(); - Result checkObjAAfterDelete = - client.data().checker().withClassName("Soup").withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testObjectCheck.assertResults(objectT, objectA, checkObjT, checkObjA, objA, objT, - checkNonexistentObject, deleteStatus, checkObjTAfterDelete, checkObjAAfterDelete); - } - - @Test - public void testDataCreateWithIDInNotUUIDFormat() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - String objID = DataTestSuite.testDataCreateWithIDInNotUUIDFormat.objID; - Map propertiesSchemaT = - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.propertiesSchemaT(); - // when - Result objectT = client.data().creator().withID(objID).withClassName("Pizza") - .withProperties(propertiesSchemaT).run(); - Result> objectsT = - client.data().objectsGetter().withClassName("Pizza").withID(objID).run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - DataTestSuite.testDataCreateWithIDInNotUUIDFormat.assertResults(objectT, objectsT, deleteStatus, - schemaAfterDelete); - } - - @Test - public void testDataGetUsingClassParameter() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // when - testGenerics.createWeaviateTestSchemaFood(client); - Result pizzaObj1 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Margherita"); - put("description", "plain"); - } - }).run(); - Result pizzaObj2 = client.data().creator().withClassName("Pizza") - .withProperties(new HashMap() { - { - put("name", "Pepperoni"); - put("description", "meat"); - } - }).run(); - Result soupObj1 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Chicken"); - put("description", "plain"); - } - }).run(); - Result soupObj2 = client.data().creator().withClassName("Soup") - .withProperties(new HashMap() { - { - put("name", "Tofu"); - put("description", "vegetarian"); - } - }).run(); - Result> objects = client.data().objectsGetter().run(); - Result> pizzaObjects = - client.data().objectsGetter().withClassName("Pizza").run(); - Result> soupObjects = - client.data().objectsGetter().withClassName("Soup").run(); - testGenerics.cleanupWeaviate(client); - // then - DataTestSuite.testDataGetUsingClassParameter.assertResults(pizzaObj1, pizzaObj2, soupObj1, - soupObj2, objects, pizzaObjects, soupObjects); - } - - private void assertCreated(Result obj) { - assertNotNull(obj); - assertNotNull(obj.getResult()); - assertNotNull(obj.getResult().getId()); - } - - private void checkArrays(Object property, int size, Object... contains) { - assertNotNull(property); - assertEquals(ArrayList.class, property.getClass()); - List l = (List) property; - assertEquals(size, l.size()); - for (Object c : contains) { - assertTrue(l.contains(c)); - } - } - - @Test - public void shouldSupportUUID() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - - String className = "ClassUUID"; - WeaviateClass clazz = - WeaviateClass.builder().className(className).description("class with uuid properties") - .properties(Arrays.asList( - Property.builder().dataType(Collections.singletonList(DataType.UUID)) - .name("uuidProp").build(), - Property.builder().dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .name("uuidArrayProp").build())) - .build(); - - String id = "abefd256-8574-442b-9293-9205193737ee"; - Map properties = new HashMap<>(); - properties.put("uuidProp", "7aaa79d3-a564-45db-8fa8-c49e20b8a39a"); - properties.put("uuidArrayProp", new String[] {"f70512a3-26cb-4ae4-9369-204555917f15", - "9e516f40-fd54-4083-a476-f4675b2b5f92"}); - - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - - assertThat(createStatus).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - - Result objectStatus = client.data().creator().withClassName(className) - .withID(id).withProperties(properties).run(); - - assertThat(objectStatus).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - Result> objectsStatus = - client.data().objectsGetter().withClassName(className).withID(id).run(); - - assertThat(objectsStatus).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1).first() - .extracting(obj -> ((WeaviateObject) obj).getProperties()) - .returns("7aaa79d3-a564-45db-8fa8-c49e20b8a39a", props -> props.get("uuidProp")) - .returns(Arrays.asList("f70512a3-26cb-4ae4-9369-204555917f15", - "9e516f40-fd54-4083-a476-f4675b2b5f92"), props -> props.get("uuidArrayProp")); - - Result deleteStatus = client.schema().allDeleter().run(); - - assertThat(deleteStatus).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - } -} diff --git a/src/test/java/io/weaviate/integration/client/data/ClientReferencesMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/data/ClientReferencesMultiTenancyTest.java deleted file mode 100644 index e1958e9b5..000000000 --- a/src/test/java/io/weaviate/integration/client/data/ClientReferencesMultiTenancyTest.java +++ /dev/null @@ -1,965 +0,0 @@ -package io.weaviate.integration.client.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.BatchReferenceResponseAO1Result; -import io.weaviate.client.v1.batch.model.BatchReferenceResponseStatus; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.AssertMultiTenancy; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientReferencesMultiTenancyTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - private AssertMultiTenancy assertMT; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - assertMT = new AssertMultiTenancy(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - - @Test - public void shouldCreateReferencesBetweenMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceCreator() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - }) - ) - ); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldNotCreateReferencesBetweenMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - - soupIds.forEach(soupId -> - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result refAddResult = client.data().referenceCreator() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .run(); - - assertMT.error(refAddResult, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }) - ); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }) - ); - } - - @Test - public void shouldDeleteReferencesBetweenMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIds, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - int[] expectedRefsLeft = new int[]{pizzaIds.size()}; - - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceDeleter() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // verify deleted one by one - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(--expectedRefsLeft[0]); - }); - }) - ); - } - - @Test - public void shouldNotDeleteReferencesBetweenMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIds, tenantNames); - - soupIds.forEach(soupId -> { - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceDeleter() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - }); - - // verify not deleted - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldReplaceReferencesBetweenMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List pizzaIdsBefore = pizzaIds.subList(0, 2); - List pizzaIdsAfter = pizzaIds.subList(2, pizzaIds.size()); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIdsBefore, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - SingleRef[] refs = pizzaIdsAfter.stream().map(pizzaId -> - client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload() - ).toArray(SingleRef[]::new); - - Result result = client.data().referenceReplacer() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReferences(refs) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - }) - ); - - // verify replaced - Arrays.stream(tenants).forEach(tenant -> { - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIdsAfter.size()); - - List beacons = getSoupResult.getResult().stream() - .map(WeaviateObject::getProperties) - .map(p -> p.get("relatedToPizza")) - .flatMap(refs -> ((List>) refs).stream()) - .map(ref -> ref.get("beacon")) - .collect(Collectors.toList()); - - pizzaIdsAfter.forEach(pizzaId -> - assertThat(beacons.stream().anyMatch(beacon -> beacon.contains(pizzaId))).isTrue() - ); - }); - }); - } - - @Test - public void shouldNotReplaceReferencesBetweenMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List pizzaIdsBefore = pizzaIds.subList(0, 2); - List pizzaIdsAfter = pizzaIds.subList(2, pizzaIds.size()); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - testGenerics.createDataPizzaForTenants(client, tenantNames); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIdsBefore, tenantNames); - - soupIds.forEach(soupId -> { - SingleRef[] refs = pizzaIdsAfter.stream().map(pizzaId -> - client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload() - ).toArray(SingleRef[]::new); - - Result result = client.data().referenceReplacer() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReferences(refs) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - - // verify not replaced - Arrays.stream(tenants).forEach(tenant -> { - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIdsBefore.size()); - - List beacons = getSoupResult.getResult().stream() - .map(WeaviateObject::getProperties) - .map(p -> p.get("relatedToPizza")) - .flatMap(refs -> ((List>) refs).stream()) - .map(ref -> ref.get("beacon")) - .collect(Collectors.toList()); - - pizzaIdsBefore.forEach(pizzaId -> - assertThat(beacons.stream().anyMatch(beacon -> beacon.contains(pizzaId))).isTrue() - ); - }); - }); - } - - @Test - public void shouldCreateReferencesBetweenMTAndNonMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceCreator() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - }) - ) - ); - - // verify created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldNotCreateReferencesBetweenMTAndNotMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - - soupIds.forEach(soupId -> - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result refAddResult = client.data().referenceCreator() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .run(); - - assertMT.error(refAddResult, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }) - ); - - // verify not created - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }) - ); - } - - @Test - public void shouldDeleteReferencesBetweenMTAndNonMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIds, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - int[] expectedRefsLeft = new int[]{pizzaIds.size()}; - - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceDeleter() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // verify deleted one by one - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(--expectedRefsLeft[0]); - }); - }) - ); - } - - @Test - public void shouldNotDeleteReferencesBetweenMTAndNonMTClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIds, tenantNames); - - soupIds.forEach(soupId -> { - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceDeleter() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - }); - - // verify not deleted - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIds.size()); - }) - ); - } - - @Test - public void shouldReplaceReferencesBetweenMTAndNonMTClasses() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List pizzaIdsBefore = pizzaIds.subList(0, 2); - List pizzaIdsAfter = pizzaIds.subList(2, pizzaIds.size()); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIdsBefore, tenantNames); - - Arrays.stream(tenants).forEach(tenant -> - soupIds.forEach(soupId -> { - SingleRef[] refs = pizzaIdsAfter.stream().map(pizzaId -> - client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload() - ).toArray(SingleRef[]::new); - - Result result = client.data().referenceReplacer() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReferences(refs) - .withTenant(tenant.getName()) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - }) - ); - - // verify replaced - Arrays.stream(tenants).forEach(tenant -> { - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIdsAfter.size()); - - List beacons = getSoupResult.getResult().stream() - .map(WeaviateObject::getProperties) - .map(p -> p.get("relatedToPizza")) - .flatMap(refs -> ((List>) refs).stream()) - .map(ref -> ref.get("beacon")) - .collect(Collectors.toList()); - - pizzaIdsAfter.forEach(pizzaId -> - assertThat(beacons.stream().anyMatch(beacon -> beacon.contains(pizzaId))).isTrue() - ); - }); - }); - } - - @Test - public void shouldNotReplaceReferencesBetweenMTAndNonMtClassesWithoutTenant() { - Tenant[] tenants = new Tenant[]{ - WeaviateTestGenerics.TENANT_1, - WeaviateTestGenerics.TENANT_2, - }; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List pizzaIdsBefore = pizzaIds.subList(0, 2); - List pizzaIdsAfter = pizzaIds.subList(2, pizzaIds.size()); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, tenants); - testGenerics.createDataSoupForTenants(client, tenantNames); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - - createSoupToPizzaRefProp(); - createSoupToPizzaRefs(soupIds, pizzaIdsBefore, tenantNames); - - soupIds.forEach(soupId -> { - SingleRef[] refs = pizzaIdsAfter.stream().map(pizzaId -> - client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload() - ).toArray(SingleRef[]::new); - - Result result = client.data().referenceReplacer() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReferences(refs) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy enabled, but request was without tenant"); - }); - - // verify not replaced - Arrays.stream(tenants).forEach(tenant -> { - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withTenant(tenant.getName()) - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")).asList() - .hasSize(pizzaIdsBefore.size()); - - List beacons = getSoupResult.getResult().stream() - .map(WeaviateObject::getProperties) - .map(p -> p.get("relatedToPizza")) - .flatMap(refs -> ((List>) refs).stream()) - .map(ref -> ref.get("beacon")) - .collect(Collectors.toList()); - - pizzaIdsBefore.forEach(pizzaId -> - assertThat(beacons.stream().anyMatch(beacon -> beacon.contains(pizzaId))).isTrue() - ); - }); - }); - } - - @Test - public void shouldNotCreateReferencesBetweenNonMTAndMTClasses() { - Tenant tenantPizza = Tenant.builder().name("tenantPizza").build(); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoup(client); - testGenerics.createDataSoup(client); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenantPizza); - testGenerics.createDataPizzaForTenants(client, tenantPizza.getName()); - - createSoupToPizzaRefProp(); - - soupIds.forEach(soupId -> - pizzaIds.forEach(pizzaId -> { - SingleRef pizzaRef = client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload(); - - Result result = client.data().referenceCreator() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReference(pizzaRef) - .withTenant(tenantPizza.getName()) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy disabled, but request was with tenant"); - }) - ); - - // verify not created - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }); - } - - @Test - public void shouldNotReplaceReferencesBetweenNonMTAndMTClasses() { - Tenant tenantPizza = Tenant.builder().name("tenantPizza").build(); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - testGenerics.createSchemaSoup(client); - testGenerics.createDataSoup(client); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenantPizza); - testGenerics.createDataPizzaForTenants(client, tenantPizza.getName()); - - createSoupToPizzaRefProp(); - - soupIds.forEach(soupId -> { - SingleRef[] refs = pizzaIds.stream().map(pizzaId -> - client.data().referencePayloadBuilder() - .withClassName("Pizza") - .withID(pizzaId) - .payload() - ).toArray(SingleRef[]::new); - - Result result = client.data().referenceReplacer() - .withClassName("Soup") - .withID(soupId) - .withReferenceProperty("relatedToPizza") - .withReferences(refs) - .withTenant(tenantPizza.getName()) - .run(); - - assertMT.error(result, false, 422, "has multi-tenancy disabled, but request was with tenant"); - }); - - // verify not replaced - soupIds.forEach(soupId -> { - Result> getSoupResult = client.data().objectsGetter() - .withClassName("Soup") - .withID(soupId) - .run(); - - assertThat(getSoupResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(1) - .first() - .extracting(o -> ((WeaviateObject) o).getProperties()) - .extracting(p -> p.get("relatedToPizza")) - .isNull(); - }); - } - - - private void createSoupToPizzaRefProp() { - Result refPropResult = client.schema().propertyCreator() - .withClassName("Soup") - .withProperty(Property.builder() - .name("relatedToPizza") - .dataType(Collections.singletonList("Pizza")) - .build()) - .run(); - - assertThat(refPropResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - private void createSoupToPizzaRefs(List soupIds, List pizzaIds, String... tenants) { - BatchReference[] references = Arrays.stream(tenants).flatMap(tenant -> - soupIds.stream().flatMap(soupId -> - pizzaIds.stream().map(pizzaId -> - client.batch().referencePayloadBuilder() - .withTenant(tenant) - .withFromClassName("Soup") - .withFromID(soupId) - .withFromRefProp("relatedToPizza") - .withToClassName("Pizza") - .withToID(pizzaId) - .payload() - ) - ) - ).toArray(BatchReference[]::new); - - Result result = client.batch().referencesBatcher() - .withReferences(references) - .run(); - - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(tenants.length * pizzaIds.size() * soupIds.size()); - - Arrays.stream(result.getResult()).forEach(item -> - assertThat(item).isNotNull() - .extracting(BatchReferenceResponse::getResult) - .isNotNull() - .returns(BatchReferenceResponseStatus.SUCCESS, BatchReferenceResponseAO1Result::getStatus) - ); - } -} diff --git a/src/test/java/io/weaviate/integration/client/data/ClientReferencesTest.java b/src/test/java/io/weaviate/integration/client/data/ClientReferencesTest.java deleted file mode 100644 index 9c1686083..000000000 --- a/src/test/java/io/weaviate/integration/client/data/ClientReferencesTest.java +++ /dev/null @@ -1,331 +0,0 @@ -package io.weaviate.integration.client.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.ObjectReference; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientReferencesTest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - private void checkReference(Result> result, String className, String refID) { - assertNotNull(result); - assertNull(result.getError()); - assertNotNull(result.getResult()); - assertNotNull(result.getResult().get(0)); - assertNotNull(result.getResult().get(0).getProperties()); - assertNotNull(result.getResult().get(0).getProperties().get("otherFoods")); - assertTrue(result.getResult().get(0).getProperties().get("otherFoods") instanceof List); - List resultOtherFoods = (List) result.getResult().get(0).getProperties().get("otherFoods"); - if (refID != null) { - assertTrue(resultOtherFoods.size() > 0); - assertNotNull(resultOtherFoods.get(0)); - assertTrue(resultOtherFoods.get(0) instanceof Map); - Map propOtherFoods = (Map) resultOtherFoods.get(0); - assertEquals(propOtherFoods.get("beacon"), "weaviate://localhost/"+className+"/"+refID); - assertEquals(propOtherFoods.get("href"), "/v1/objects/"+className+"/"+refID); - } else { - assertEquals(resultOtherFoods.size(), 0); - } - } - - @Test - public void testDataCreateWithReferenceCreate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - } - - @Test - public void testDataCreateWithReferenceReplace() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - // Replace the above reference with self references - // Thing -> Thing - Result otherFoodsPizzaRefReplace = client.data().referenceReplacer() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ hawaiiRef }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - // Action -> Action - Result otherFoodsSoupRefReplace = client.data().referenceReplacer() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ chickenSoupRef }) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result> thingsReplaced = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run(); - Result> actionsReplaced = client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - // check objT replaced - checkReference(thingsReplaced, "Pizza", objTID); - // check objA replaced - checkReference(actionsReplaced, "Soup", objAID); - } - - @Test - public void testDataCreateWithReferenceDelete() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).withClassName("Soup").payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).withClassName("Pizza").payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run(); - Result> actions = client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - // Delete ref - Result otherFoodsPizzaRefDelete = client.data().referenceDeleter() - .withID(objTID) - .withClassName("Pizza") - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - Result otherFoodsSoupRefDelete = client.data().referenceDeleter() - .withID(objAID) - .withClassName("Soup") - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .withConsistencyLevel(ConsistencyLevel.QUORUM) - .run(); - // Get the objects - Result> thingsAfterRefDelete = client.data().objectsGetter().withID(objTID).withClassName("Pizza").run(); - Result> actionsAfterRefDelete = client.data().objectsGetter().withID(objAID).withClassName("Soup").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, "Soup", objAID); - // check objA - checkReference(actions, "Pizza", objTID); - // check ref delete - assertNotNull(otherFoodsPizzaRefDelete); - assertNull(otherFoodsPizzaRefDelete.getError()); - assertTrue(otherFoodsPizzaRefDelete.getResult()); - assertNotNull(otherFoodsSoupRefDelete); - assertNull(otherFoodsSoupRefDelete.getError()); - assertTrue(otherFoodsSoupRefDelete.getResult()); - // check objT after delete, should be null - checkReference(thingsAfterRefDelete, null, null); - // check objA after delete, should be null - checkReference(actionsAfterRefDelete, null, null); - } - - @Test - public void testDataCreateWithAddReferenceUsingProperties() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objRefBeaconID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba92"; - Map propertiesSchemaRefBeacon = new HashMap() {{ - put("name", "RefBeaconSoup"); - put("description", "Used only to check if reference can be added."); - put("otherFoods", new ObjectReference[]{ - ObjectReference.builder().beacon("weaviate://localhost/Pizza/abefd256-8574-442b-9293-9205193737ee").build() - }); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - // create object with a reference to objT - Result objRefBeaconCreate = client.data().creator() - .withClassName("Soup") - .withID(objRefBeaconID) - .withProperties(propertiesSchemaRefBeacon) - .run(); - // Get the object reference beacon to check if otherFoods reference has been set - Result> objRefBeaconGet = client.data().objectsGetter().withID(objRefBeaconID).withClassName("Soup").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objRefBeaconCreate); - assertNull(objRefBeaconCreate.getError()); - // check objT - checkReference(objRefBeaconGet, "Pizza", objTID); - } -} diff --git a/src/test/java/io/weaviate/integration/client/deprecated/batch/ClientBatchCreateDeprecatedAPITest.java b/src/test/java/io/weaviate/integration/client/deprecated/batch/ClientBatchCreateDeprecatedAPITest.java deleted file mode 100644 index 3496b7ae6..000000000 --- a/src/test/java/io/weaviate/integration/client/deprecated/batch/ClientBatchCreateDeprecatedAPITest.java +++ /dev/null @@ -1,221 +0,0 @@ -package io.weaviate.integration.client.deprecated.batch; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchReference; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.junit.Assert; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientBatchCreateDeprecatedAPITest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose("1.13.2"); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - @Test - public void testBatchCreate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // objT1 - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - // objT2 - String objT2ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - Map propertiesSchemaT2 = new HashMap<>(); - propertiesSchemaT2.put("name", "Doener"); - propertiesSchemaT2.put("description", "A innovation, some say revolution, in the pizza industry."); - WeaviateObject objT2 = WeaviateObject.builder().className("Pizza").id(objT2ID).properties(propertiesSchemaT2).build(); - // objA1 - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // objA2 - String objA2ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - Map propertiesSchemaA2 = new HashMap<>(); - propertiesSchemaA2.put("name", "Beautiful"); - propertiesSchemaA2.put("description", "Putting the game of letter soups to a whole new level."); - WeaviateObject objA2 = WeaviateObject.builder().className("Soup").id(objA2ID).properties(propertiesSchemaA2).build(); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objT1 = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objA1 = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result batchTs = client.batch().objectsBatcher() - .withObject(objT1.getResult()) - .withObject(objT2) - .run(); - Result batchAs = client.batch().objectsBatcher() - .withObject(objA1.getResult()) - .withObject(objA2) - .run(); - // check if created objects exist - Result> getObjT1 = client.data().objectsGetter().withID(objTID).run(); - Result> getObjT2 = client.data().objectsGetter().withID(objT2ID).run(); - Result> getObjA1 = client.data().objectsGetter().withID(objAID).run(); - Result> getObjA2 = client.data().objectsGetter().withID(objA2ID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objT1); - assertNotNull(objT1.getResult()); - assertEquals(objTID, objT1.getResult().getId()); - assertNotNull(objA1); - assertNotNull(objA1.getResult()); - assertEquals(objAID, objA1.getResult().getId()); - assertNotNull(batchTs); - assertNotNull(batchTs.getResult()); - assertEquals(2, batchTs.getResult().length); - assertNotNull(batchAs); - assertNotNull(batchAs.getResult()); - assertEquals(2, batchAs.getResult().length); - assertNotNull(getObjT1); - assertNotNull(getObjT1.getResult()); - assertEquals(1, getObjT1.getResult().size()); - assertEquals(objTID, getObjT1.getResult().get(0).getId()); - assertNotNull(getObjT2); - assertNotNull(getObjT2.getResult()); - assertEquals(1, getObjT2.getResult().size()); - assertEquals(objT2ID, getObjT2.getResult().get(0).getId()); - assertNotNull(getObjA1); - assertNotNull(getObjA1.getResult()); - assertEquals(1, getObjA1.getResult().size()); - assertEquals(objAID, getObjA1.getResult().get(0).getId()); - assertNotNull(getObjA2); - assertEquals(1, getObjA2.getResult().size()); - assertEquals(objA2ID, getObjA2.getResult().get(0).getId()); - } - - @Test - public void testBatchReferences() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // classT - String classTID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - // classA - String classAID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - // references - BatchReference refTtoA = BatchReference.builder() - .from("weaviate://localhost/Pizza/97fa5147-bdad-4d74-9a81-f8babc811b09/otherFoods") - .to("weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af") - .build(); - BatchReference refAtoT = BatchReference.builder() - .from("weaviate://localhost/Soup/07473b34-0ab2-4120-882d-303d9e13f7af/otherFoods") - .to("weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09") - .build(); - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client, true); - Result classT = client.data().creator() - .withClassName("Pizza") - .withID(classTID) - .withProperties(new HashMap() {{ - put("name", "Doener"); - put("description", "A innovation, some say revolution, in the pizza industry."); - }}) - .run(); - Result classA = client.data().creator() - .withClassName("Soup") - .withID(classAID) - .withProperties(new HashMap() {{ - put("name", "Beautiful"); - put("description", "Putting the game of letter soups to a whole new level."); - }}) - .run(); - Result createClassT = client.batch().objectsBatcher().withObject(classT.getResult()).run(); - Result createClassA = client.batch().objectsBatcher().withObject(classA.getResult()).run(); - BatchReference refTtoT = client.batch().referencePayloadBuilder() - .withFromClassName("Pizza") - .withFromRefProp("otherFoods") - .withFromID(classTID) - .withToID(classTID) - .payload(); - BatchReference refAtoA = client.batch().referencePayloadBuilder() - .withFromClassName("Soup") - .withFromRefProp("otherFoods") - .withFromID(classAID) - .withToID(classAID) - .payload(); - Result refResult = client.batch().referencesBatcher() - .withReference(refTtoA).withReference(refTtoT).withReference(refAtoT).withReference(refAtoA) - .run(); - Result> objT = client.data().objectsGetter().withID(classTID).run(); - Result> objA = client.data().objectsGetter().withID(classAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(createClassT); - assertNotNull(createClassT.getResult()); - assertEquals(1, createClassT.getResult().length); - assertNotNull(createClassA); - assertNotNull(createClassA.getResult()); - assertEquals(1, createClassA.getResult().length); - assertNotNull(refTtoT); - assertNotNull(refAtoA); - assertNotNull(refResult); - assertNotNull(refResult.getResult()); - assertEquals(4, refResult.getResult().length); - // assert objT - assertNotNull(objT); - assertNotNull(objT.getResult()); - assertEquals(1, objT.getResult().size()); - assertEquals(classTID, objT.getResult().get(0).getId()); - assertNotNull(classTID, objT.getResult().get(0).getProperties()); - assertNotNull(classTID, objT.getResult().get(0).getProperties().get("otherFoods")); - Assert.assertTrue(objT.getResult().get(0).getProperties().get("otherFoods") instanceof List); - List otherFoods = (List) objT.getResult().get(0).getProperties().get("otherFoods"); - Assert.assertEquals(2, otherFoods.size()); - Assert.assertTrue(otherFoods.get(0) instanceof Map); - Map otherFood0 = (Map) otherFoods.get(0); - Map otherFood1 = (Map) otherFoods.get(1); - List beacons = Stream.of(otherFood0.get("beacon"), otherFood1.get("beacon")).collect(Collectors.toList()); - Assert.assertTrue(beacons.contains("weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af")); - Assert.assertTrue(beacons.contains("weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09")); - // assert objA - assertNotNull(objA); - assertNotNull(objA.getResult()); - assertEquals(1, objA.getResult().size()); - assertEquals(classAID, objA.getResult().get(0).getId()); - assertNotNull(classAID, objA.getResult().get(0).getProperties()); - assertNotNull(classAID, objA.getResult().get(0).getProperties().get("otherFoods")); - Assert.assertTrue(objA.getResult().get(0).getProperties().get("otherFoods") instanceof List); - otherFoods = (List) objA.getResult().get(0).getProperties().get("otherFoods"); - Assert.assertEquals(2, otherFoods.size()); - Assert.assertTrue(otherFoods.get(0) instanceof Map); - otherFood0 = (Map) otherFoods.get(0); - otherFood1 = (Map) otherFoods.get(1); - beacons = Stream.of(otherFood0.get("beacon"), otherFood1.get("beacon")).collect(Collectors.toList()); - Assert.assertTrue(beacons.contains("weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af")); - Assert.assertTrue(beacons.contains("weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09")); - } -} diff --git a/src/test/java/io/weaviate/integration/client/deprecated/data/ClientDataDeprecatedAPITest.java b/src/test/java/io/weaviate/integration/client/deprecated/data/ClientDataDeprecatedAPITest.java deleted file mode 100644 index 1603c036d..000000000 --- a/src/test/java/io/weaviate/integration/client/deprecated/data/ClientDataDeprecatedAPITest.java +++ /dev/null @@ -1,808 +0,0 @@ -package io.weaviate.integration.client.deprecated.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; - -public class ClientDataDeprecatedAPITest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose("1.13.2"); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - @Test - public void testDataCreate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result> objectsT = client.data().objectsGetter().withID(objTID).run(); - Result> objectsA = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(2, objectsT.getResult().get(0).getProperties().size()); - assertEquals("Pizza", objectsT.getResult().get(0).getClassName()); - assertEquals("Hawaii", objectsT.getResult().get(0).getProperties().get("name")); - assertNotNull(objectsA); - assertNotNull(objectsA.getResult()); - assertEquals(1, objectsA.getResult().size()); - assertEquals(objAID, objectsA.getResult().get(0).getId()); - assertNotNull(objectsA.getResult().get(0).getProperties()); - assertEquals(2, objectsA.getResult().get(0).getProperties().size()); - assertEquals("Soup", objectsA.getResult().get(0).getClassName()); - assertEquals("ChickenSoup", objectsA.getResult().get(0).getProperties().get("name")); - } - - @Test - public void testDataCreateWithSpecialCharacters() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String name = "Zażółć gęślą jaźń"; - String description = "test äüëö"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", name); - propertiesSchemaT.put("description", description); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withID(objTID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(2, objectsT.getResult().get(0).getProperties().size()); - assertEquals("Pizza", objectsT.getResult().get(0).getClassName()); - assertEquals(name, objectsT.getResult().get(0).getProperties().get("name")); - assertEquals(description, objectsT.getResult().get(0).getProperties().get("description")); - } - - @Test - public void testDataGetActionsThings() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result pizzaObj1 = client.data().creator().withClassName("Pizza").withProperties(new HashMap() {{ - put("name", "Margherita"); - put("description", "plain"); - }}).run(); - Result pizzaObj2 = client.data().creator().withClassName("Pizza").withProperties(new HashMap() {{ - put("name", "Pepperoni"); - put("description", "meat"); - }}).run(); - Result soupObj1 = client.data().creator().withClassName("Soup").withProperties(new HashMap() {{ - put("name", "Chicken"); - put("description", "plain"); - }}).run(); - Result soupObj2 = client.data().creator().withClassName("Soup").withProperties(new HashMap() {{ - put("name", "Tofu"); - put("description", "vegetarian"); - }}).run(); - Result> objects = client.data().objectsGetter().run(); - Result> objects1 = client.data().objectsGetter().withLimit(1).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(pizzaObj1); - assertNotNull(pizzaObj1.getResult()); - assertNotNull(pizzaObj1.getResult().getId()); - assertNotNull(pizzaObj2); - assertNotNull(pizzaObj2.getResult()); - assertNotNull(pizzaObj2.getResult().getId()); - assertNotNull(soupObj1); - assertNotNull(soupObj1.getResult()); - assertNotNull(soupObj1.getResult().getId()); - assertNotNull(soupObj2); - assertNotNull(soupObj2.getResult()); - assertNotNull(soupObj2.getResult().getId()); - assertNotNull(objects); - assertNotNull(objects.getResult()); - assertEquals(4, objects.getResult().size()); - assertNotNull(objects1); - assertNotNull(objects1.getResult()); - assertEquals(1, objects1.getResult().size()); - } - - @Test - public void testDataGetWithAdditional() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result> objectsT = client.data().objectsGetter().withID(objTID).run(); - Result> objectsA = client.data().objectsGetter().withID(objAID).run(); - Result> objsAdditionalT = client.data() - .objectsGetter().withID(objTID) - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withVector() - .run(); - Result> objsAdditionalA = client.data() - .objectsGetter().withID(objAID) - .withAdditional("classification") - .withAdditional("nearestNeighbors") - .withAdditional("interpretation") - .withVector() - .run(); - Result> objsAdditionalA1 = client.data() - .objectsGetter().withID(objAID) - .run(); - Result> objsAdditionalA2 = client.data() - .objectsGetter().withID(objAID) - .withAdditional("interpretation") - .run(); - Result> objsAdditionalAError = client.data() - .objectsGetter().withID(objAID) - .withAdditional("featureProjection") - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertNull(objectsT.getResult().get(0).getAdditional()); - assertNotNull(objectsA); - assertNotNull(objectsA.getResult()); - assertEquals(1, objectsA.getResult().size()); - assertNull(objectsA.getResult().get(0).getAdditional()); - assertNotNull(objsAdditionalT); - assertNotNull(objsAdditionalT.getResult()); - assertEquals(1, objsAdditionalT.getResult().size()); - assertNotNull(objsAdditionalT.getResult().get(0).getAdditional()); - assertEquals(2, objsAdditionalT.getResult().get(0).getAdditional().size()); - assertNull(objsAdditionalT.getResult().get(0).getAdditional().get("classification")); - assertNotNull(objsAdditionalT.getResult().get(0).getAdditional().get("nearestNeighbors")); - assertNotNull(objsAdditionalT.getResult().get(0).getVector()); - assertNotNull(objsAdditionalA); - assertNotNull(objsAdditionalA.getResult()); - assertEquals(1, objsAdditionalA.getResult().size()); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional()); - assertEquals(3, objsAdditionalA.getResult().get(0).getAdditional().size()); - assertNull(objsAdditionalA.getResult().get(0).getAdditional().get("classification")); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional().get("nearestNeighbors")); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional().get("interpretation")); - assertNotNull(objsAdditionalA.getResult().get(0).getVector()); - assertNotNull(objsAdditionalA1.getResult()); - assertEquals(1, objsAdditionalA1.getResult().size()); - assertNull(objsAdditionalA1.getResult().get(0).getAdditional()); - assertNotNull(objsAdditionalA2.getResult()); - assertEquals(1, objsAdditionalA2.getResult().size()); - assertNotNull(objsAdditionalA2.getResult().get(0).getAdditional()); - assertEquals(1, objsAdditionalA2.getResult().get(0).getAdditional().size()); - assertNotNull(objsAdditionalA2.getResult().get(0).getAdditional().get("interpretation")); - assertNotNull(objsAdditionalAError); - assertNull(objsAdditionalAError.getResult()); - } - - @Test - public void testDataDelete() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result deleteObjT = client.data().deleter().withID(objTID).run(); - Result> objTlist = client.data().objectsGetter().withID(objTID).run(); - Result deleteObjA = client.data().deleter().withID(objAID).run(); - Result> objAlist = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(deleteObjT); - assertTrue(deleteObjT.getResult()); - assertNotNull(objTlist); - assertNull(objTlist.getResult()); - assertNotNull(deleteObjA); - assertTrue(deleteObjA.getResult()); - assertNotNull(objAlist); - assertNull(objAlist.getResult()); - } - - @Test - public void testDataUpdate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Random"); - propertiesSchemaT.put("description", "Missing description"); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "water"); - propertiesSchemaA.put("description", "missing description"); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result updateObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) - .withProperties(new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}) - .run(); - Result updateObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) - .withProperties(new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}) - .run(); - Result> updatedObjsT = client.data().objectsGetter().withID(objTID).run(); - Result> updatedObjsA = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(updateObjectT); - assertTrue(updateObjectT.getResult()); - assertNotNull(updateObjectA); - assertTrue(updateObjectA.getResult()); - assertNotNull(updatedObjsT); - assertNotNull(updatedObjsT.getResult()); - assertEquals(1, updatedObjsT.getResult().size()); - assertEquals("Hawaii", updatedObjsT.getResult().get(0).getProperties().get("name")); - assertEquals("Universally accepted to be the best pizza ever created.", updatedObjsT.getResult().get(0).getProperties().get("description")); - assertNotNull(updatedObjsA); - assertNotNull(updatedObjsA.getResult()); - assertEquals(1, updatedObjsA.getResult().size()); - assertEquals("ChickenSoup", updatedObjsA.getResult().get(0).getProperties().get("name")); - assertEquals("Used by humans when their inferior genetics are attacked by microscopic organisms.", updatedObjsA.getResult().get(0).getProperties().get( - "description")); - } - - @Test - public void testDataMerge() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Missing description"); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "missing description"); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result mergeObjectT = client.data().updater() - .withClassName("Pizza") - .withID(objTID) - .withProperties(new HashMap() {{ - put("description", "Universally accepted to be the best pizza ever created."); - }}) - .withMerge() - .run(); - Result mergeObjectA = client.data().updater() - .withClassName("Soup") - .withID(objAID) - .withProperties(new HashMap() {{ - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}) - .withMerge() - .run(); - Result> mergedObjsT = client.data().objectsGetter().withID(objTID).run(); - Result> mergeddObjsA = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(mergeObjectT); - assertTrue(mergeObjectT.getResult()); - assertNotNull(mergeObjectA); - assertTrue(mergeObjectA.getResult()); - assertNotNull(mergedObjsT); - assertNotNull(mergedObjsT.getResult()); - assertEquals(1, mergedObjsT.getResult().size()); - assertEquals("Hawaii", mergedObjsT.getResult().get(0).getProperties().get("name")); - assertEquals("Universally accepted to be the best pizza ever created.", mergedObjsT.getResult().get(0).getProperties().get("description")); - assertNotNull(mergeddObjsA); - assertNotNull(mergeddObjsA.getResult()); - assertEquals(1, mergeddObjsA.getResult().size()); - assertEquals("ChickenSoup", mergeddObjsA.getResult().get(0).getProperties().get("name")); - assertEquals("Used by humans when their inferior genetics are attacked by microscopic organisms.", mergeddObjsA.getResult().get(0).getProperties().get( - "description")); - } - - @Test - public void testDataValidate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result validateObjT = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result validateObjA = client.data().validator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - propertiesSchemaT.put("test", "not existing property"); - Result validateObjT1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - propertiesSchemaA.put("test", "not existing property"); - Result validateObjA1 = client.data().validator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(validateObjT); - assertTrue(validateObjT.getResult()); - assertNotNull(validateObjA); - assertTrue(validateObjA.getResult()); - assertNotNull(validateObjT1); - assertNotNull(validateObjT1.getError()); - assertEquals("invalid object: no such prop with name 'test' found in class 'Pizza' in the schema." + - " Check your schema files for which properties in this class are available", - validateObjT1.getError().getMessages().get(0).getMessage()); - assertNotNull(validateObjA1); - assertNotNull(validateObjA1.getError()); - assertEquals("invalid object: no such prop with name 'test' found in class 'Pizza' in the schema." + - " Check your schema files for which properties in this class are available", - validateObjA1.getError().getMessages().get(0).getMessage()); - } - - @Test - public void testDataGetWithAdditionalError() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - Result> objsAdditionalT = client.data() - .objectsGetter().withID(objTID) - .withAdditional("featureProjection") - .withVector() - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertNotNull(objsAdditionalT); - assertNotNull(objsAdditionalT.getError()); - assertNotNull(objsAdditionalT.getError().getMessages()); - assertEquals("get extend: unknown capability: featureProjection", objsAdditionalT.getError().getMessages().get(0).getMessage()); - } - - @Test - public void testDataCreateWithArrayType() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateClass clazz = WeaviateClass.builder() - .className("ClassArrays") - .description("Class which properties are all array properties") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.TEXT_ARRAY); }}) - .name("stringArray") - .build()); - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.TEXT_ARRAY); }}) - .name("textArray") - .build()); - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.INT_ARRAY); }}) - .name("intArray") - .build()); - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.NUMBER_ARRAY); }}) - .name("numberArray") - .build()); - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.BOOLEAN_ARRAY); }}) - .name("booleanArray") - .build()); - }}) - .build(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("stringArray", new String[]{"a", "b"}); - propertiesSchemaT.put("textArray", new String[]{"c", "d"}); - propertiesSchemaT.put("intArray", new Integer[]{1, 2}); - propertiesSchemaT.put("numberArray", new Float[]{3.3f, 4.4f}); - propertiesSchemaT.put("booleanArray", new Boolean[]{true, false}); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator() - .withClassName("ClassArrays") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withID(objTID).run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().size()); - // data check - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(5, objectsT.getResult().get(0).getProperties().size()); - assertEquals("ClassArrays", objectsT.getResult().get(0).getClassName()); - checkArrays(objectsT.getResult().get(0).getProperties().get("stringArray"), 2, "a", "b"); - checkArrays(objectsT.getResult().get(0).getProperties().get("textArray"), 2, "c", "d"); - checkArrays(objectsT.getResult().get(0).getProperties().get("intArray"), 2, 1.0, 2.0); - checkArrays(objectsT.getResult().get(0).getProperties().get("numberArray"), 2, 3.3, 4.4); - checkArrays(objectsT.getResult().get(0).getProperties().get("booleanArray"), 2, true, false); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - - @Test - public void testDataGetWithVector() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateClass clazz = WeaviateClass.builder() - .className("ClassCustomVector") - .description("Class with custom vector") - .vectorizer("none") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList(){{ add(DataType.TEXT); }}) - .name("foo") - .build()); - }}) - .build(); - String objTID = "addfd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("foo", "bar"); - Float[] vectorObjT = new Float[]{-0.26736435f, -0.112380296f, 0.29648793f, 0.39212644f, 0.0033650293f, -0.07112332f, 0.07513781f, 0.22459874f}; - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result objectT = client.data().creator() - .withClassName("ClassCustomVector") - .withID(objTID) - .withVector(vectorObjT) - .withProperties(propertiesSchemaT) - .run(); - Result> objT = client.data() - .objectsGetter().withID(objTID) - .withVector() - .run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().size()); - // check the object - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertNotNull(objT); - assertNull(objT.getError()); - assertNotNull(objT.getResult()); - assertEquals(objT.getResult().size(), 1); - assertArrayEquals(objT.getResult().get(0).getVector(), vectorObjT); - // clean up - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - - @Test - public void testObjectCheck() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - String nonExistentObjectID = "11111111-1111-1111-aaaa-aaaaaaaaaaaa"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - // when - testGenerics.createWeaviateTestSchemaFood(client, true); - Result objectT = client.data().creator() - .withClassName("Pizza") - .withID(objTID) - .withProperties(propertiesSchemaT) - .run(); - Result objectA = client.data().creator() - .withClassName("Soup") - .withID(objAID) - .withProperties(propertiesSchemaA) - .run(); - // check object existence - Result checkObjT = client.data().checker().withID(objTID).run(); - Result checkObjA = client.data().checker().withID(objAID).run(); - Result> objA = client.data() - .objectsGetter().withID(objAID) - .withVector() - .run(); - Result> objT = client.data() - .objectsGetter().withID(objTID) - .withVector() - .run(); - Result checkNonexistentObject = client.data().checker().withID(nonExistentObjectID).run(); - // delete all objects from Weaviate - Result deleteStatus = client.schema().allDeleter().run(); - // check object's existence status after clean up - Result checkObjTAfterDelete = client.data().checker().withID(objTID).run(); - Result checkObjAAfterDelete = client.data().checker().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(checkObjT); - assertTrue(checkObjT.getResult()); - assertNotNull(checkObjA); - assertTrue(checkObjA.getResult()); - assertNotNull(objA.getResult()); - assertEquals(objA.getResult().size(), 1); - assertEquals(objA.getResult().get(0).getId(), objAID); - assertNotNull(objT.getResult()); - assertEquals(objT.getResult().size(), 1); - assertEquals(objT.getResult().get(0).getId(), objTID); - assertNotNull(checkNonexistentObject); - assertFalse(checkNonexistentObject.getResult()); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertNotNull(checkObjTAfterDelete); - assertFalse(checkObjTAfterDelete.getResult()); - assertNull(checkObjTAfterDelete.getError()); - assertNotNull(checkObjAAfterDelete); - assertFalse(checkObjAAfterDelete.getResult()); - assertNull(checkObjAAfterDelete.getError()); - } - - @Test - public void testDataCreateWithIDInNotUUIDFormat() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - String objID = "TODO_4"; - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "name"); - propertiesSchemaT.put("description", "description"); - // when - Result objectT = client.data().creator() - .withID(objID) - .withClassName("Pizza") - .withProperties(propertiesSchemaT) - .run(); - Result> objectsT = client.data().objectsGetter().withID(objID).run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - assertNotNull(objectT); - assertNull(objectT.getResult()); - assertNotNull(objectT.getError()); - assertNotNull(objectT.getError().getMessages()); - assertNotNull(objectT.getError().getMessages().get(0)); - assertEquals(422, objectT.getError().getStatusCode()); - assertEquals("id in body must be of type uuid: \"TODO_4\"", objectT.getError().getMessages().get(0).getMessage()); - assertNotNull(objectsT); - assertNull(objectsT.getResult()); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - - private void checkArrays(Object property, int size, Object... contains) { - assertNotNull(property); - assertEquals(ArrayList.class, property.getClass()); - List l = (List) property; - assertEquals(size, l.size()); - for (Object c : contains) { - assertTrue(l.contains(c)); - } - } -} - diff --git a/src/test/java/io/weaviate/integration/client/deprecated/data/ClientReferencesDeprecatedAPITest.java b/src/test/java/io/weaviate/integration/client/deprecated/data/ClientReferencesDeprecatedAPITest.java deleted file mode 100644 index 6e3c0960a..000000000 --- a/src/test/java/io/weaviate/integration/client/deprecated/data/ClientReferencesDeprecatedAPITest.java +++ /dev/null @@ -1,312 +0,0 @@ -package io.weaviate.integration.client.deprecated.data; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.ObjectReference; -import io.weaviate.client.v1.data.model.SingleRef; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientReferencesDeprecatedAPITest { - private String address; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose("1.13.2"); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - } - - private void checkReference(Result> result, String refID) { - assertNotNull(result); - assertNull(result.getError()); - assertNotNull(result.getResult()); - assertNotNull(result.getResult().get(0)); - assertNotNull(result.getResult().get(0).getProperties()); - assertNotNull(result.getResult().get(0).getProperties().get("otherFoods")); - assertTrue(result.getResult().get(0).getProperties().get("otherFoods") instanceof List); - List resultOtherFoods = (List) result.getResult().get(0).getProperties().get("otherFoods"); - if (refID != null) { - assertTrue(resultOtherFoods.size() > 0); - assertNotNull(resultOtherFoods.get(0)); - assertTrue(resultOtherFoods.get(0) instanceof Map); - Map propOtherFoods = (Map) resultOtherFoods.get(0); - assertEquals(propOtherFoods.get("beacon"), "weaviate://localhost/"+refID); - assertEquals(propOtherFoods.get("href"), "/v1/objects/"+refID); - } else { - assertEquals(resultOtherFoods.size(), 0); - } - } - - @Test - public void testDataCreateWithReferenceCreate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client, true); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).run(); - Result> actions = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, objAID); - // check objA - checkReference(actions, objTID); - } - - @Test - public void testDataCreateWithReferenceReplace() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).payload(); - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).payload(); - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client, true); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).run(); - Result> actions = client.data().objectsGetter().withID(objAID).run(); - // Replace the above reference with self references - // Thing -> Thing - Result otherFoodsPizzaRefReplace = client.data().referenceReplacer() - .withID(objTID) - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ hawaiiRef }) - .run(); - // Action -> Action - Result otherFoodsSoupRefReplace = client.data().referenceReplacer() - .withID(objAID) - .withReferenceProperty("otherFoods") - .withReferences(new SingleRef[]{ chickenSoupRef }) - .run(); - Result> thingsReplaced = client.data().objectsGetter().withID(objTID).run(); - Result> actionsReplaced = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, objAID); - // check objA - checkReference(actions, objTID); - // check objT replaced - checkReference(thingsReplaced, objTID); - // check objA replaced - checkReference(actionsReplaced, objAID); - } - - @Test - public void testDataCreateWithReferenceDelete() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - Map propertiesSchemaA = new HashMap() {{ - put("name", "ChickenSoup"); - put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client, true); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - Result objACreate = client.data().creator().withClassName("Soup").withID(objAID).withProperties(propertiesSchemaA).run(); - // Thing -> Action - // Payload to reference the ChickenSoup - SingleRef chickenSoupRef = client.data().referencePayloadBuilder().withID(objAID).payload(); - // Add the reference to the ChickenSoup to the Pizza OtherFoods reference - Result otherFoodsPizzaRefCreate = client.data().referenceCreator() - .withID(objTID) - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef) - .run(); - // Action -> Thing - // Payload to reference the Hawaii - SingleRef hawaiiRef = client.data().referencePayloadBuilder().withID(objTID).payload(); - // Add the reference to the Hawaii to the Soup OtherFoods reference - Result otherFoodsSoupRefCreate = client.data().referenceCreator() - .withID(objAID) - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef) - .run(); - // Get the objects - Result> things = client.data().objectsGetter().withID(objTID).run(); - Result> actions = client.data().objectsGetter().withID(objAID).run(); - // Delete ref - Result otherFoodsPizzaRefDelete = client.data().referenceDeleter() - .withID(objTID) - .withReferenceProperty("otherFoods") - .withReference(chickenSoupRef).run(); - Result otherFoodsSoupRefDelete = client.data().referenceDeleter() - .withID(objAID) - .withReferenceProperty("otherFoods") - .withReference(hawaiiRef).run(); - // Get the objects - Result> thingsAfterRefDelete = client.data().objectsGetter().withID(objTID).run(); - Result> actionsAfterRefDelete = client.data().objectsGetter().withID(objAID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objACreate); - assertNull(objACreate.getError()); - assertNotNull(otherFoodsPizzaRefCreate); - assertNull(otherFoodsPizzaRefCreate.getError()); - assertTrue(otherFoodsPizzaRefCreate.getResult()); - assertNotNull(otherFoodsSoupRefCreate); - assertNull(otherFoodsSoupRefCreate.getError()); - assertTrue(otherFoodsSoupRefCreate.getResult()); - // check objT - checkReference(things, objAID); - // check objA - checkReference(actions, objTID); - // check ref delete - assertNotNull(otherFoodsPizzaRefDelete); - assertNull(otherFoodsPizzaRefDelete.getError()); - assertTrue(otherFoodsPizzaRefDelete.getResult()); - assertNotNull(otherFoodsSoupRefDelete); - assertNull(otherFoodsSoupRefDelete.getError()); - assertTrue(otherFoodsSoupRefDelete.getResult()); - // check objT after delete, should be null - checkReference(thingsAfterRefDelete, null); - // check objA after delete, should be null - checkReference(actionsAfterRefDelete, null); - } - - @Test - public void testDataCreateWithAddReferenceUsingProperties() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String objTID = "abefd256-8574-442b-9293-9205193737ee"; - Map propertiesSchemaT = new HashMap() {{ - put("name", "Hawaii"); - put("description", "Universally accepted to be the best pizza ever created."); - }}; - String objRefBeaconID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba92"; - Map propertiesSchemaRefBeacon = new HashMap() {{ - put("name", "RefBeaconSoup"); - put("description", "Used only to check if reference can be added."); - put("otherFoods", new ObjectReference[]{ - ObjectReference.builder().beacon("weaviate://localhost/abefd256-8574-442b-9293-9205193737ee").build() - }); - }}; - // when - testGenerics.createWeaviateTestSchemaFoodWithReferenceProperty(client, true); - Result objTCreate = client.data().creator().withClassName("Pizza").withID(objTID).withProperties(propertiesSchemaT).run(); - // create object with a reference to objT - Result objRefBeaconCreate = client.data().creator() - .withClassName("Soup") - .withID(objRefBeaconID) - .withProperties(propertiesSchemaRefBeacon) - .run(); - // Get the object reference beacon to check if otherFoods reference has been set - Result> objRefBeaconGet = client.data().objectsGetter().withID(objRefBeaconID).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(objTCreate); - assertNull(objTCreate.getError()); - assertNotNull(objRefBeaconCreate); - assertNull(objRefBeaconCreate.getError()); - // check objT - checkReference(objRefBeaconGet, objTID); - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/AbstractClientGraphQLTest.java b/src/test/java/io/weaviate/integration/client/graphql/AbstractClientGraphQLTest.java deleted file mode 100644 index a4ffad124..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/AbstractClientGraphQLTest.java +++ /dev/null @@ -1,133 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.Serializer; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.integration.client.WeaviateTestGenerics; -import lombok.AllArgsConstructor; -import lombok.Getter; -import org.assertj.core.api.Assertions; - -import java.util.*; -import java.util.stream.Collectors; - -/** AbstractClientGraphQLTest has fixtures and assertion utils used for both sync and async tests. */ -public abstract class AbstractClientGraphQLTest { - protected static final WeaviateTestGenerics.DocumentPassageSchema testData = new WeaviateTestGenerics.DocumentPassageSchema(); - - @Getter - @AllArgsConstructor - protected static class AdditionalOfDocument { - String id; - } - - @Getter - protected static class Additional { - Group group; - } - - @Getter - protected static class AdditionalGroupByAdditional { - Additional _additional; - } - - @Getter - @AllArgsConstructor - protected static class AdditionalGroupHit { - String id; - Float distance; - } - - - @Getter - @AllArgsConstructor - protected static class GroupHitOfDocument { - AdditionalOfDocument _additional; - } - - @Getter - @AllArgsConstructor - protected static class GroupHit { - AdditionalGroupHit _additional; - List ofDocument; - } - - @Getter - @AllArgsConstructor - protected static class GroupedBy { - public String value; - public String[] path; - } - - @Getter - @AllArgsConstructor - protected static class Group { - public String id; - public GroupedBy groupedBy; - public Integer count; - public Float maxDistance; - public Float minDistance; - public List hits; - } - - protected static final List ofDocumentA = Collections.singletonList( - new GroupHitOfDocument(new AdditionalOfDocument(testData.DOCUMENT_IDS[0])) - ); - protected static final List ofDocumentB = Collections.singletonList( - new GroupHitOfDocument(new AdditionalOfDocument(testData.DOCUMENT_IDS[1])) - ); - - protected static final List expectedHitsA = new ArrayList() { - { - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[0], 4.172325e-7f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[8], 0.0023148656f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[6], 0.0023562312f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[7], 0.0025092363f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[5], 0.002709806f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[9], 0.002762556f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[4], 0.0028533936f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[3], 0.0033442378f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[2], 0.004181564f), ofDocumentA)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[1], 0.0057129264f), ofDocumentA)); - } - }; - - protected static final List expectedHitsB = new ArrayList() { - { - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[10], 0.0025351048f), ofDocumentB)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[12], 0.00288558f), ofDocumentB)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[11], 0.0033002496f), ofDocumentB)); - this.add(new GroupHit(new AdditionalGroupHit(testData.PASSAGE_IDS[13], 0.004168868f), ofDocumentB)); - } - }; - - protected void assertIds(String className, Result gqlResult, String[] expectedIds) { - Assertions.assertThat(gqlResult).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).isInstanceOf(List.class).asList().hasSize(expectedIds.length); - - List> results = (List>) ((Map) (((Map) - (gqlResult.getResult().getData())).get("Get"))).get(className); - String[] resultIds = results.stream().map(m -> m.get("_additional")).map(a -> ((Map) a).get("id")).toArray(String[]::new); - Assertions.assertThat(resultIds).containsExactlyInAnyOrder(expectedIds); - } - - protected List getGroups(List> result) { - Serializer serializer = new Serializer(); - String jsonString = serializer.toJsonString(result); - AdditionalGroupByAdditional[] response = serializer.toResponse(jsonString, AdditionalGroupByAdditional[].class); - Assertions.assertThat(response).isNotNull().hasSize(3); - return Arrays.stream(response).map(AdditionalGroupByAdditional::get_additional).map(Additional::getGroup).collect(Collectors.toList()); - } - - protected void checkGroupElements(List expected, List actual) { - Assertions.assertThat(expected).hasSameSizeAs(actual); - for (int i = 0; i < actual.size(); i++) { - Assertions.assertThat(actual.get(i).get_additional().getId()).isEqualTo(expected.get(i).get_additional().getId()); - Assertions.assertThat(actual.get(i).getOfDocument().get(0).get_additional().getId()) - .isEqualTo(expected.get(i).getOfDocument().get(0).get_additional().getId()); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTargetSearchTest.java b/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTargetSearchTest.java deleted file mode 100644 index eda577cf8..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTargetSearchTest.java +++ /dev/null @@ -1,323 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.Targets; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.PQConfig; -import io.weaviate.client.v1.misc.model.SQConfig; -import io.weaviate.client.v1.misc.model.RQConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateVersion; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import static org.junit.Assert.assertNull; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientGraphQLMultiTargetSearchTest { - private WeaviateClient client; - - private final String id1 = "00000000-0000-0000-0000-000000000001"; - private final String id2 = "00000000-0000-0000-0000-000000000002"; - private final String id3 = "00000000-0000-0000-0000-000000000003"; - - private final String titleAndContent = "titleAndContent"; - private final String title1 = "title1"; - private final String title2 = "title2"; - private final String title3 = "title3"; - private final String bringYourOwnVector = "bringYourOwnVector"; - private final String bringYourOwnVector2 = "bringYourOwnVector2"; - - @ClassRule - public static WeaviateDockerCompose compose = - new WeaviateDockerCompose(WeaviateVersion.WEAVIATE_IMAGE); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - String grpcHost = compose.getGrpcHostAddress(); - Config config = new Config("http", httpHost); - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - - client = new WeaviateClient(config); - } - - @Test - public void shouldPerformMultiTargetSearch() throws InterruptedException { - String className = "MultiTargetSearch"; - setupDB(className); - Field _additional = Field.builder().name("_additional").fields(new Field[] { - Field.builder().name("id").build(), Field.builder().name("distance").build()}) - .build(); - // nearText - Map weights = new HashMap<>(); - weights.put(titleAndContent, 0.1f); - weights.put(title1, 0.6f); - weights.put(title2, 0.3f); - weights.put(title3, 0.1f); - Targets targets = Targets.builder() - .targetVectors(new String[] {titleAndContent, title1, title2, title3}) - .combinationMethod(Targets.CombinationMethod.manualWeights).weights(weights) - .build(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] {"Water black"}).targets(targets).build(); - Result response = client.graphQL().get().withClassName(className) - .withNearText(nearText).withFields(_additional).run(); - assertGetContainsIds(response, className, id1, id2, id3); - // nearVector with single vector-per-target - Map vectorPerTarget = new HashMap<>(); - vectorPerTarget.put(bringYourOwnVector, new Float[] {.99f, .88f, .77f}); - vectorPerTarget.put(bringYourOwnVector2, new Float[] {.11f, .22f, .33f}); - weights = new HashMap() { - { - this.put(bringYourOwnVector, 0.1f); - this.put(bringYourOwnVector2, 0.6f); - } - }; - targets = Targets.builder() - .targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2}) - .combinationMethod(Targets.CombinationMethod.manualWeights).weights(weights) - .build(); - NearVectorArgument nearVector = client.graphQL().arguments().nearVectorArgBuilder() - .vectorPerTarget(vectorPerTarget).targets(targets).build(); - response = client.graphQL().get().withClassName(className).withNearVector(nearVector) - .withFields(_additional).run(); - assertNull("check error in response:", response.getError()); - assertGetContainsIds(response, className, id2, id3); - // nearVector with multiple vector-per-target - Map vectorsPerTarget = new HashMap<>(); - vectorsPerTarget.put(bringYourOwnVector, - new Float[][] {new Float[] {.99f, .88f, .77f}, new Float[] {.99f, .88f, .77f}}); - vectorsPerTarget.put(bringYourOwnVector2, new Float[][] {new Float[] {.11f, .22f, .33f}}); - Map weightsMulti = new HashMap<>(); - weightsMulti.put(bringYourOwnVector, new Float[] {0.5f, 0.5f}); - weightsMulti.put(bringYourOwnVector2, new Float[] {0.6f}); - targets = Targets.builder() - .targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2}) - .combinationMethod(Targets.CombinationMethod.manualWeights) - .weightsMulti(weightsMulti).build(); - nearVector = client.graphQL().arguments().nearVectorArgBuilder() - .vectorsPerTarget(vectorsPerTarget).targets(targets).build(); - response = client.graphQL().get().withClassName(className).withNearVector(nearVector) - .withFields(_additional).run(); - assertNull("check error in response:", response.getError()); - assertGetContainsIds(response, className, id2, id3); - // nearObject - targets = Targets.builder() - .targetVectors(new String[] {bringYourOwnVector, bringYourOwnVector2, - titleAndContent, title1, title2, title3}) - .combinationMethod(Targets.CombinationMethod.average).build(); - NearObjectArgument nearObject = client.graphQL().arguments().nearObjectArgBuilder().id(id3) - .targets(targets).build(); - response = client.graphQL().get().withClassName(className).withNearObject(nearObject) - .withFields(_additional).run(); - assertGetContainsIds(response, className, id2, id3); - } - - private void setupDB(String className) { - // clean - Result delete = client.schema().allDeleter().run(); - assertThat(delete).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - // create class - List properties = Arrays.asList( - Property.builder().name("title").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("content") - .dataType(Collections.singletonList(DataType.TEXT)).build(), - Property.builder().name("title1").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("title2").dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder().name("title3").dataType(Collections.singletonList(DataType.TEXT)) - .build()); - Map vectorConfig = new HashMap<>(); - vectorConfig.put(titleAndContent, getTitleAndContentVectorConfig()); - vectorConfig.put(title1, getTitle1VectorConfig()); - vectorConfig.put(title2, getTitle2VectorConfig()); - vectorConfig.put(title3, getTitle3VectorConfig()); - vectorConfig.put(bringYourOwnVector, getBringYourOwnVectorVectorConfig()); - vectorConfig.put(bringYourOwnVector2, getBringYourOwnVectorVectorConfig2()); - Result createResult = client.schema().classCreator() - .withClass(WeaviateClass.builder().className(className).properties(properties) - .vectorConfig(vectorConfig).build()) - .run(); - assertThat(createResult).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - // add data - // obj1 - Map props1 = new HashMap<>(); - props1.put("title", "The Lord of the Rings"); - props1.put("content", "A great fantasy novel"); - props1.put("title1", "J.R.R. Tolkien The Lord of the Rings"); - props1.put("title2", "Rings"); - props1.put("title3", "Book"); - Float[] vector1a = new Float[] {0.77f, 0.88f, 0.77f}; - Map vectors1 = new HashMap<>(); - vectors1.put("bringYourOwnVector", vector1a); - // don't add vector for bringYourOwnVector2 - // obj2 - Map props2 = new HashMap<>(); - props2.put("title", "Black Oceans"); - props2.put("content", "A great science fiction book"); - props2.put("title1", "Jacek Dukaj Black Oceans"); - props2.put("title2", "Water"); - props2.put("title3", "Book"); - Float[] vector2a = new Float[] {0.11f, 0.22f, 0.33f}; - Float[] vector2b = new Float[] {0.11f, 0.11f, 0.11f}; - Map vectors2 = new HashMap<>(); - vectors2.put("bringYourOwnVector", vector2a); - vectors2.put("bringYourOwnVector2", vector2b); - // obj2 - Map props3 = new HashMap<>(); - props3.put("title", "Into the Water"); - props3.put("content", - "New York Times bestseller and global phenomenon The Girl on the Train returns with Into the Water"); - props3.put("title1", "Paula Hawkins Into the Water"); - props3.put("title2", "Water go into it"); - props3.put("title3", "Book"); - Float[] vector3a = new Float[] {0.99f, 0.88f, 0.77f}; - Float[] vector3b = new Float[] {0.99f, 0.88f, 0.77f}; - Map vectors3 = new HashMap<>(); - vectors3.put("bringYourOwnVector", vector3a); - vectors3.put("bringYourOwnVector2", vector3b); - - WeaviateObject obj1 = createObject(id1, className, props1, vectors1); - WeaviateObject obj2 = createObject(id2, className, props2, vectors2); - WeaviateObject obj3 = createObject(id3, className, props3, vectors3); - - Result result = - client.batch().objectsBatcher().withObjects(obj1, obj2, obj3).run(); - assertThat(result).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY).hasSize(3); - } - - private WeaviateClass.VectorConfig getTitleAndContentVectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title", "content"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWSQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle1VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title1"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWPQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle2VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title2"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getTitle3VectorConfig() { - Map titleAndContent = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] {"title3"}); - titleAndContent.put("text2vec-contextionary", text2vecContextionarySettings); - return getHNSWRQVectorConfig(titleAndContent); - } - - private WeaviateClass.VectorConfig getBringYourOwnVectorVectorConfig() { - Map byov = new HashMap<>(); - byov.put("none", new Object()); - return getFlatBQVectorConfig(byov); - } - - private WeaviateClass.VectorConfig getBringYourOwnVectorVectorConfig2() { - Map byov = new HashMap<>(); - byov.put("none", new Object()); - return getFlatVectorConfig(byov); - } - - private WeaviateClass.VectorConfig getFlatBQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("flat") - .vectorizer(vectorizerConfig).vectorIndexConfig(VectorIndexConfig.builder() - .bq(BQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getFlatVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("flat") - .vectorizer(vectorizerConfig).build(); - } - - private WeaviateClass.VectorConfig getHNSWVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw") - .vectorizer(vectorizerConfig).build(); - } - - private WeaviateClass.VectorConfig getHNSWPQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw") - .vectorizer(vectorizerConfig).vectorIndexConfig(VectorIndexConfig.builder() - .pq(PQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWSQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw") - .vectorizer(vectorizerConfig).vectorIndexConfig(VectorIndexConfig.builder() - .sq(SQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateClass.VectorConfig getHNSWRQVectorConfig(Map vectorizerConfig) { - return WeaviateClass.VectorConfig.builder().vectorIndexType("hnsw") - .vectorizer(vectorizerConfig).vectorIndexConfig(VectorIndexConfig.builder() - .rq(RQConfig.builder().enabled(true).build()).build()) - .build(); - } - - private WeaviateObject createObject(String id, String className, Map props, - Map vectors) { - WeaviateObject.WeaviateObjectBuilder obj = - WeaviateObject.builder().id(id).className(className).properties(props); - if (vectors != null) { - obj = obj.vectors(vectors); - } - return obj.build(); - } - - private void assertGetContainsIds(Result response, String className, - String... expectedIds) { - assertThat(response).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull().extracting(GraphQLResponse::getData) - .isInstanceOf(Map.class).extracting(data -> ((Map) data).get("Get")) - .isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)) - .isInstanceOf(List.class).asList().hasSize(expectedIds.length) - .extracting(obj -> ((Map) obj).get("_additional")) - .extracting(add -> ((Map) add).get("id")) - .containsExactlyInAnyOrder(expectedIds); - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTenancyTest.java deleted file mode 100644 index c24200ac2..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLMultiTenancyTest.java +++ /dev/null @@ -1,283 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_1; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_2; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import org.assertj.core.api.AbstractObjectAssert; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientGraphQLMultiTenancyTest { - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - - @Test - public void shouldGetAllDataForTenant() { - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(client, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(client, TENANT_2.getName()); - - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_HAWAII_ID, - WeaviateTestGenerics.PIZZA_DOENER_ID, - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = client.graphQL().get() - .withTenant(tenant) - .withClassName("Pizza") - .withFields(Field.builder() - .name("_additional") - .fields(Field.builder().name("id").build()) - .build()) - .run(); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldGetLimitedDataForTenant() { - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(client, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(client, TENANT_2.getName()); - - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_HAWAII_ID, - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = client.graphQL().get() - .withTenant(tenant) - .withClassName("Pizza") - .withLimit(1) - .withFields(Field.builder() - .name("_additional") - .fields(Field.builder().name("id").build()) - .build()) - .run(); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldGetFilteredDataForTenant() { - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(client, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(client, TENANT_2.getName()); - - Map expectedIdsByTenant = new HashMap<>(); - expectedIdsByTenant.put(TENANT_1.getName(), new String[]{ - WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID, - }); - expectedIdsByTenant.put(TENANT_2.getName(), new String[]{ - }); - - expectedIdsByTenant.forEach((tenant, expectedIds) -> { - Result response = client.graphQL().get() - .withTenant(tenant) - .withClassName("Pizza") - .withWhere(WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"price"}) - .operator(Operator.GreaterThan) - .valueNumber(2.0d) - .build()) - .build()) - .withFields(Field.builder() - .name("_additional") - .fields(Field.builder().name("id").build()) - .build()) - .run(); - - assertGetContainsIds(response, "Pizza", expectedIds); - }); - } - - @Test - public void shouldAggregateAllDataForTenant() { - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(client, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(client, TENANT_2.getName()); - - Map> expectedAggValuesByTenant = new HashMap<>(); - expectedAggValuesByTenant.put(TENANT_1.getName(), new HashMap() {{ - put("count", 2.0); - put("maximum", 2.5); - put("minimum", 1.4); - put("median", 1.95); - put("mean", 1.95); - put("mode", 1.4); - put("sum", 3.9); - }}); - expectedAggValuesByTenant.put(TENANT_2.getName(), new HashMap() {{ - put("count", 2.0); - put("maximum", 1.2); - put("minimum", 1.1); - put("median", 1.15); - put("mean", 1.15); - put("mode", 1.1); - put("sum", 2.3); - }}); - - expectedAggValuesByTenant.forEach((tenant, expectedAggValues) -> { - Result response = client.graphQL().aggregate() - .withTenant(tenant) - .withClassName("Pizza") - .withFields(Field.builder() - .name("price") - .fields( - Field.builder().name("count").build(), - Field.builder().name("maximum").build(), - Field.builder().name("minimum").build(), - Field.builder().name("median").build(), - Field.builder().name("mean").build(), - Field.builder().name("mode").build(), - Field.builder().name("sum").build()) - .build()) - .run(); - - assertAggregateNumFieldHasValues(response, "Pizza", "price", expectedAggValues); - }); - } - - @Test - public void shouldAggregateFilteredDataForTenant() { - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, TENANT_1, TENANT_2); - testGenerics.createDataPizzaQuattroFormaggiForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaFruttiDiMareForTenants(client, TENANT_1.getName()); - testGenerics.createDataPizzaHawaiiForTenants(client, TENANT_2.getName()); - testGenerics.createDataPizzaDoenerForTenants(client, TENANT_2.getName()); - - Map> expectedAggValuesByTenant = new HashMap<>(); - expectedAggValuesByTenant.put(TENANT_1.getName(), new HashMap() {{ - put("count", 1.0); - put("maximum", 2.5); - put("minimum", 2.5); - put("median", 2.5); - put("mean", 2.5); - put("mode", 2.5); - put("sum", 2.5); - }}); - expectedAggValuesByTenant.put(TENANT_2.getName(), new HashMap() {{ - put("count", 0.0); - put("maximum", null); - put("minimum", null); - put("median", null); - put("mean", null); - put("mode", null); - put("sum", null); - }}); - - expectedAggValuesByTenant.forEach((tenant, expectedAggValues) -> { - Result response = client.graphQL().aggregate() - .withTenant(tenant) - .withClassName("Pizza") - .withWhere(WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[]{"price"}) - .operator(Operator.GreaterThan) - .valueNumber(2.0d) - .build()) - .build()) - .withFields(Field.builder() - .name("price") - .fields( - Field.builder().name("count").build(), - Field.builder().name("maximum").build(), - Field.builder().name("minimum").build(), - Field.builder().name("median").build(), - Field.builder().name("mean").build(), - Field.builder().name("mode").build(), - Field.builder().name("sum").build()) - .build()) - .run(); - - assertAggregateNumFieldHasValues(response, "Pizza", "price", expectedAggValues); - }); - } - - private void assertGetContainsIds(Result response, String className, String... expectedIds) { - assertThat(response).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).isInstanceOf(List.class).asList() - .hasSize(expectedIds.length) - .extracting(obj -> ((Map) obj).get("_additional")) - .extracting(add -> ((Map) add).get("id")) - .containsExactlyInAnyOrder(expectedIds); - } - - private void assertAggregateNumFieldHasValues(Result response, String className, String fieldName, - Map expectedAggValues) { - AbstractObjectAssert aggregate = assertThat(response).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Aggregate")).isInstanceOf(Map.class) - .extracting(agg -> ((Map) agg).get(className)).isInstanceOf(List.class).asList() - .hasSize(1) - .first() - .extracting(obj -> ((Map) obj).get(fieldName)).isInstanceOf(Map.class); - - expectedAggValues.forEach((name, value) -> aggregate.returns(value, map -> ((Map) map).get(name))); - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTest.java b/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTest.java deleted file mode 100644 index 4d57d46fa..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTest.java +++ /dev/null @@ -1,2393 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assume.assumeTrue; - -import java.time.ZoneOffset; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Collections; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.TimeZone; -import java.util.function.BiConsumer; -import java.util.function.Function; -import java.util.stream.IntStream; - -import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.time.DateFormatUtils; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Ignore; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.ExploreFields; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument; -import io.weaviate.client.v1.graphql.query.argument.Bm25Argument.SearchOperator; -import io.weaviate.client.v1.graphql.query.argument.GroupArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupByArgument; -import io.weaviate.client.v1.graphql.query.argument.GroupType; -import io.weaviate.client.v1.graphql.query.argument.HybridArgument; -import io.weaviate.client.v1.graphql.query.argument.NearObjectArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextArgument; -import io.weaviate.client.v1.graphql.query.argument.NearTextMoveParameters; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.SortArgument; -import io.weaviate.client.v1.graphql.query.argument.SortOrder; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.GenerativeSearchBuilder; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; - -public class ClientGraphQLTest extends AbstractClientGraphQLTest { - private String address; - private String openAIApiKey; - private static final WeaviateTestGenerics.DocumentPassageSchema testData = new WeaviateTestGenerics.DocumentPassageSchema(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - address = compose.getHttpHostAddress(); - openAIApiKey = System.getenv("OPENAI_APIKEY"); - } - - @Test - public void testGraphQLGet() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza").withFields(name).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - assertEquals(4, getPizza.size()); - } - - @Test - public void testRawGraphQL() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().raw().withQuery("{Get{Pizza{_additional{id}}}}").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - assertEquals(4, getPizza.size()); - } - - @Test - public void testGraphQLGetWithNearObjectAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - WeaviateObject soupWithID = WeaviateObject.builder().className("Soup").id(newObjID) - .properties(new HashMap() { - { - put("name", "JustSoup"); - put("description", "soup with id"); - } - }).build(); - NearObjectArgument nearObjectArgument = client.graphQL().arguments().nearObjectArgBuilder() - .id(newObjID).certainty(0.99f).build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(soupWithID).run(); - Result result = client.graphQL().get().withClassName("Soup") - .withNearObject(nearObjectArgument) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(1, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Soup")); - assertTrue(get.get("Soup") instanceof List); - List getSoup = (List) get.get("Soup"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithNearObjectAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - WeaviateObject soupWithID = WeaviateObject.builder().className("Soup").id(newObjID) - .properties(new HashMap() { - { - put("name", "JustSoup"); - put("description", "soup with id"); - } - }).build(); - NearObjectArgument nearObjectArgument = client.graphQL().arguments().nearObjectArgBuilder() - .id(newObjID).distance(0.01f).build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(soupWithID).run(); - Result result = client.graphQL().get().withClassName("Soup") - .withNearObject(nearObjectArgument) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(1, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Soup")); - assertTrue(get.get("Soup") instanceof List); - List getSoup = (List) get.get("Soup"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testBm25() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - Bm25Argument bm25 = client.graphQL().arguments().bm25ArgBuilder() - .query("innovation") - .properties(new String[] { "description" }) - .build(); - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withBm25(bm25) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizza = (List) get.get("Pizza"); - assertEquals(1, pizza.size()); - Map fields = (Map) pizza.get(0); - String descr = (String) fields.get("description"); - assertTrue(descr.contains("innovation")); - } - - @Test - public void testBm25_searchOperator_And() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - Bm25Argument bm25 = client.graphQL().arguments().bm25ArgBuilder() - .query("innovation") - .properties(new String[] { "description" }) - .searchOperator(SearchOperator.and()) - .build(); - - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withBm25(bm25) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertNull(result.getError()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizza = (List) get.get("Pizza"); - assertEquals(1, pizza.size()); - Map fields = (Map) pizza.get(0); - String descr = (String) fields.get("description"); - assertTrue(descr.contains("innovation")); - } - - @Test - public void testBm25_searchOperator_Or() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - Bm25Argument bm25 = client.graphQL().arguments().bm25ArgBuilder() - .query("innovation") - .properties(new String[] { "description" }) - .searchOperator(SearchOperator.or(1)) - .build(); - - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withBm25(bm25) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertNull(result.getError()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizza = (List) get.get("Pizza"); - assertEquals(1, pizza.size()); - Map fields = (Map) pizza.get(0); - String descr = (String) fields.get("description"); - assertTrue(descr.contains("innovation")); - } - - @Test - public void testHybrid() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - HybridArgument hybrid = client.graphQL().arguments().hybridArgBuilder() - .query("some say revolution") - .alpha(0.8f) - .build(); - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withHybrid(hybrid) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - } - - @Test - public void testHybrid_bm25SearchOperator_And() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - HybridArgument hybrid = client.graphQL().arguments().hybridArgBuilder() - .query("some say revolution") - .alpha(0.8f) - .bm25SearchOperator(SearchOperator.and()) - .build(); - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withHybrid(hybrid) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - } - - @Test - public void testHybrid_bm25SearchOperator_Or() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - HybridArgument hybrid = client.graphQL().arguments().hybridArgBuilder() - .query("some say revolution") - .alpha(0.8f) - .bm25SearchOperator(SearchOperator.or(1)) - .build(); - Field name = Field.builder().name("description").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withHybrid(hybrid) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - } - - @Test - public void testGraphQLGetWithNearTextAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[] { "Universally" }).force(0.8f) - .build(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .moveAwayFrom(moveAway) - .certainty(0.8f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withNearText(nearText) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getSoup = (List) get.get("Pizza"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithNearTextAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .concepts(new String[] { "Universally" }).force(0.8f) - .build(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .moveAwayFrom(moveAway) - .distance(0.4f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withNearText(nearText) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getSoup = (List) get.get("Pizza"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithNearTextAndMoveParamsAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID1 = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - String newObjID2 = "6baed48e-2afe-4be4-a09d-b00a955d962a"; - WeaviateObject pizzaWithID = WeaviateObject.builder().className("Pizza").id(newObjID1) - .properties(new HashMap() { - { - put("name", "JustPizza1"); - put("description", "Universally pizza with id"); - } - }).build(); - WeaviateObject pizzaWithID2 = WeaviateObject.builder().className("Pizza").id(newObjID2) - .properties(new HashMap() { - { - put("name", "JustPizza2"); - put("description", "Universally pizza with some other id"); - } - }).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { - NearTextMoveParameters.ObjectMove.builder().id(newObjID1).build() - }).force(0.9f).build(); - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { - NearTextMoveParameters.ObjectMove.builder().id(newObjID2).build() - }).force(0.9f).build(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "Universally pizza with id" }) - .moveAwayFrom(moveAway) - .moveTo(moveTo) - .certainty(0.4f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(pizzaWithID, pizzaWithID2).run(); - Result result = client.graphQL().get() - .withClassName("Pizza") - .withNearText(nearText) - .withFields(name, _additional) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(2, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizzas = (List) get.get("Pizza"); - assertEquals(6, pizzas.size()); - } - - @Test - public void testGraphQLGetWithNearTextAndMoveParamsAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID1 = "6baed48e-2afe-4be4-a09d-b00a955d962b"; - String newObjID2 = "6baed48e-2afe-4be4-a09d-b00a955d962a"; - WeaviateObject pizzaWithID = WeaviateObject.builder().className("Pizza").id(newObjID1) - .properties(new HashMap() { - { - put("name", "JustPizza1"); - put("description", "Universally pizza with id"); - } - }).build(); - WeaviateObject pizzaWithID2 = WeaviateObject.builder().className("Pizza").id(newObjID2) - .properties(new HashMap() { - { - put("name", "JustPizza2"); - put("description", "Universally pizza with some other id"); - } - }).build(); - NearTextMoveParameters moveAway = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { - NearTextMoveParameters.ObjectMove.builder().id(newObjID1).build() - }).force(0.9f).build(); - NearTextMoveParameters moveTo = NearTextMoveParameters.builder() - .objects(new NearTextMoveParameters.ObjectMove[] { - NearTextMoveParameters.ObjectMove.builder().id(newObjID2).build() - }).force(0.9f).build(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "Universally pizza with id" }) - .moveAwayFrom(moveAway) - .moveTo(moveTo) - .distance(0.6f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(pizzaWithID, pizzaWithID2).run(); - Result result = client.graphQL().get() - .withClassName("Pizza") - .withNearText(nearText) - .withFields(name, _additional) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(2, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizzas = (List) get.get("Pizza"); - assertEquals(6, pizzas.size()); - } - - @Test - public void testGraphQLGetWithNearTextAndLimitAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .certainty(0.8f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withNearText(nearText) - .withLimit(1) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getSoup = (List) get.get("Pizza"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithNearTextAndLimitAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - NearTextArgument nearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(new String[] { "some say revolution" }) - .distance(0.4f) - .build(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("certainty").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get().withClassName("Pizza") - .withNearText(nearText) - .withLimit(1) - .withFields(name, _additional).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getSoup = (List) get.get("Pizza"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithWhereByFieldTokenizedProperty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - - WhereArgument whereFullString = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "name" }) - .operator(Operator.Equal) - .valueText("Frutti di Mare") - .build()) - .build(); - WhereArgument wherePartString = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "name" }) - .operator(Operator.Equal) - .valueText("Frutti") - .build()) - .build(); - WhereArgument whereFullText = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "description" }) - .operator(Operator.Equal) - .valueText("Universally accepted to be the best pizza ever created.") - .build()) - .build(); - WhereArgument wherePartText = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "description" }) - .operator(Operator.Equal) - .valueText("Universally") - .build()) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result resultFullString = client.graphQL().get().withWhere(whereFullString).withClassName("Pizza") - .withFields(name).run(); - Result resultPartString = client.graphQL().get().withWhere(wherePartString).withClassName("Pizza") - .withFields(name).run(); - Result resultFullText = client.graphQL().get().withWhere(whereFullText).withClassName("Pizza") - .withFields(name).run(); - Result resultPartText = client.graphQL().get().withWhere(wherePartText).withClassName("Pizza") - .withFields(name).run(); - testGenerics.cleanupWeaviate(client); - // then - assertWhereResultSize(1, resultFullString, "Pizza"); - assertWhereResultSize(0, resultPartString, "Pizza"); - assertWhereResultSize(1, resultFullText, "Pizza"); - assertWhereResultSize(1, resultPartText, "Pizza"); - } - - @Test - public void shouldSupportDeprecatedValueString() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - WhereArgument whereString = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "name" }) - .operator(Operator.Equal) - .valueString("Frutti di Mare") - .build()) - .build(); - - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get() - .withWhere(whereString) - .withClassName("Pizza") - .withFields(Field.builder().name("name").build()) - .run(); - testGenerics.cleanupWeaviate(client); - - assertWhereResultSize(1, result, "Pizza"); - } - - @Test - public void testGraphQLGetWithWhereByDate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - - Calendar cal = Calendar.getInstance(); - cal.set(2022, Calendar.FEBRUARY, 1, 0, 0, 0); - - WhereArgument whereDate = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "bestBefore" }) - .operator(Operator.GreaterThan) - .valueDate(cal.getTime()) - .build()) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result resultDate = client.graphQL().get().withWhere(whereDate).withClassName("Pizza") - .withFields(name).run(); - testGenerics.cleanupWeaviate(client); - // then - List> maps = extractResult(resultDate, "Pizza"); - assertThat(maps).hasSize(3) - .extracting(el -> (String) el.get("name")) - .contains("Frutti di Mare", "Hawaii", "Doener"); - } - - /** - * @see https://github.com/weaviate/java-client/pull/456#issuecomment-3270249876 - */ - @Ignore("Regression in Explorer API in v1.33") - @Test - public void testGraphQLExploreWithCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - ExploreFields[] fields = new ExploreFields[] { ExploreFields.CERTAINTY, ExploreFields.BEACON, - ExploreFields.CLASS_NAME }; - String[] concepts = new String[] { "pineapple slices", "ham" }; - NearTextMoveParameters moveTo = client.graphQL().arguments().nearTextMoveParameterBuilder() - .concepts(new String[] { "Pizza" }).force(0.3f).build(); - NearTextMoveParameters moveAwayFrom = client.graphQL().arguments().nearTextMoveParameterBuilder() - .concepts(new String[] { "toast", "bread" }).force(0.4f).build(); - NearTextArgument withNearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(concepts).certainty(0.40f) - .moveTo(moveTo).moveAwayFrom(moveAwayFrom) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().explore().withFields(fields).withNearText(withNearText).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNull(resp.getErrors()); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Explore")); - assertTrue(data.get("Explore") instanceof List); - List get = (List) data.get("Explore"); - assertEquals(6, get.size()); - } - - /** - * @see https://github.com/weaviate/java-client/pull/456#issuecomment-3270249876 - */ - @Ignore("Regression in Explorer API in v1.33") - @Test - public void testGraphQLExploreWithDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - ExploreFields[] fields = new ExploreFields[] { ExploreFields.CERTAINTY, ExploreFields.BEACON, - ExploreFields.CLASS_NAME }; - String[] concepts = new String[] { "pineapple slices", "ham" }; - NearTextMoveParameters moveTo = client.graphQL().arguments().nearTextMoveParameterBuilder() - .concepts(new String[] { "Pizza" }).force(0.3f).build(); - NearTextMoveParameters moveAwayFrom = client.graphQL().arguments().nearTextMoveParameterBuilder() - .concepts(new String[] { "toast", "bread" }).force(0.4f).build(); - NearTextArgument withNearText = client.graphQL().arguments().nearTextArgBuilder() - .concepts(concepts).distance(0.80f) - .moveTo(moveTo).moveAwayFrom(moveAwayFrom) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().explore().withFields(fields).withNearText(withNearText).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNull(resp.getErrors()); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Explore")); - assertTrue(data.get("Explore") instanceof List); - List get = (List) data.get("Explore"); - assertEquals(6, get.size()); - } - - @Test - public void testGraphQLAggregate() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithWhereFilter() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder().className("Pizza").id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }).build(); - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "id" }) - .operator(Operator.Equal) - .valueText(newObjID) - .build()) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(pizzaWithID).run(); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza") - .withWhere(where).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(1, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 1.0d); - } - - @Test - public void testGraphQLAggregateWithGroupedByAndWhere() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder().className("Pizza").id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }).build(); - WhereArgument where = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "id" }) - .operator(Operator.Equal) - .valueText(newObjID) - .build()) - .build(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(pizzaWithID).run(); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza") - .withGroupBy("name").withWhere(where).run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(1, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 1.0d); - } - - @Test - public void testGraphQLAggregateWithGroupedBy() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - String newObjID = "6baed48e-2afe-4be4-a09d-b00a955d96ee"; - WeaviateObject pizzaWithID = WeaviateObject.builder().className("Pizza").id(newObjID) - .properties(new HashMap() { - { - put("name", "JustPizza"); - put("description", "pizza with id"); - } - }).build(); - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - // when - testGenerics.createTestSchemaAndData(client); - Result insert = client.batch().objectsBatcher().withObjects(pizzaWithID).run(); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza") - .withGroupBy("name").run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(insert); - assertNotNull(insert.getResult()); - assertEquals(1, insert.getResult().length); - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 5, 1.0d); - } - - @Test - public void testGraphQLAggregateWithNearVector() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - Field additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("vector").build() }) - .build(); - Result result = client.graphQL().get().withClassName("Pizza").withFields(additional).run(); - GraphQLResponse resp = result.getResult(); - Float[] vec = getVectorFromResponse(resp); - - // when - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearVectorArgument nearVector = NearVectorArgument.builder().certainty(0.7f).vector(vec).build(); - result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza").withNearVector(nearVector).run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearObjectAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - Field additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - Result result = client.graphQL().get().withClassName("Pizza").withFields(additional).run(); - GraphQLResponse resp = result.getResult(); - String id = getAdditionalFieldFromResponse(resp, "id"); - - // when - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearObjectArgument nearObject = NearObjectArgument.builder().certainty(0.7f).id(id).build(); - result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza").withNearObject(nearObject).run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearObjectAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - Field additional = Field.builder() - .name("_additional") - .fields(new Field[] { Field.builder().name("id").build() }) - .build(); - Result result = client.graphQL().get().withClassName("Pizza").withFields(additional).run(); - GraphQLResponse resp = result.getResult(); - String id = getAdditionalFieldFromResponse(resp, "id"); - - // when - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearObjectArgument nearObject = NearObjectArgument.builder().distance(0.3f).id(id).build(); - result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza").withNearObject(nearObject).run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearTextAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - // when - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearTextArgument nearText = NearTextArgument.builder().certainty(0.7f).concepts(new String[] { "pizza" }).build(); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza") - .withNearText(nearText).run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithNearTextAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - // when - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearTextArgument nearText = NearTextArgument.builder().distance(0.6f).concepts(new String[] { "pizza" }).build(); - Result result = client.graphQL().aggregate().withFields(meta).withClassName("Pizza") - .withNearText(nearText).run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, 4.0d); - } - - @Test - public void testGraphQLAggregateWithObjectLimitAndCertainty() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - // when - Integer objectLimit = 1; - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearTextArgument nearText = NearTextArgument.builder().certainty(0.7f).concepts(new String[] { "pizza" }).build(); - Result result = client.graphQL() - .aggregate() - .withFields(meta) - .withClassName("Pizza") - .withNearText(nearText) - .withObjectLimit(objectLimit) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, Double.valueOf(objectLimit)); - } - - @Test - public void testGraphQLAggregateWithObjectLimitAndDistance() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - // when - Integer objectLimit = 1; - Field meta = Field.builder() - .name("meta") - .fields(new Field[] { Field.builder().name("count").build() }) - .build(); - NearTextArgument nearText = NearTextArgument.builder().distance(0.3f).concepts(new String[] { "pizza" }).build(); - Result result = client.graphQL() - .aggregate() - .withFields(meta) - .withClassName("Pizza") - .withNearText(nearText) - .withObjectLimit(objectLimit) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - assertNotNull(result); - assertNotNull(result.getResult()); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - checkAggregateMetaCount(resp, 1, Double.valueOf(objectLimit)); - } - - @Test - public void testGraphQLGetWithGroup() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - GroupArgument group = client.graphQL().arguments().groupArgBuilder() - .type(GroupType.merge).force(1.0f).build(); - Field name = Field.builder().name("name").build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Soup") - .withFields(name) - .withGroup(group) - .withLimit(7) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Soup")); - assertTrue(get.get("Soup") instanceof List); - List getSoup = (List) get.get("Soup"); - assertEquals(1, getSoup.size()); - } - - @Test - public void testGraphQLGetWithSort() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - SortArgument byNameDesc = client.graphQL().arguments().sortArgBuilder() - .path(new String[] { "name" }) - .order(SortOrder.desc) - .build(); - String[] expectedByNameDesc = new String[] { "Quattro Formaggi", "Hawaii", "Frutti di Mare", "Doener" }; - SortArgument byPriceAsc = client.graphQL().arguments().sortArgBuilder() - .path(new String[] { "price" }) - .order(SortOrder.asc) - .build(); - String[] expectedByPriceAsc = new String[] { "Hawaii", "Doener", "Quattro Formaggi", "Frutti di Mare" }; - // when - testGenerics.createTestSchemaAndData(client); - Result resultByNameDesc = client.graphQL().get() - .withClassName("Pizza") - .withSort(byNameDesc) - .withFields(name).run(); - Result resultByDescriptionAsc = client.graphQL().get() - .withClassName("Pizza") - .withSort(byPriceAsc) - .withFields(name).run(); - Result resultByNameDescByPriceAsc = client.graphQL().get() - .withClassName("Pizza") - .withSort(byNameDesc, byPriceAsc) - .withFields(name).run(); - testGenerics.cleanupWeaviate(client); - // then - expectPizzaNamesOrder(resultByNameDesc, expectedByNameDesc); - expectPizzaNamesOrder(resultByDescriptionAsc, expectedByPriceAsc); - expectPizzaNamesOrder(resultByNameDescByPriceAsc, expectedByNameDesc); - } - - @Test - public void testGraphQLGetWithTimestampFilters() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - Field additional = Field.builder() - .name("_additional") - .fields(new Field[] { - Field.builder().name("id").build(), - Field.builder().name("creationTimeUnix").build(), - Field.builder().name("lastUpdateTimeUnix").build() - }) - .build(); - Result expected = client.graphQL().get().withClassName("Pizza").withFields(additional).run(); - GraphQLResponse resp = expected.getResult(); - String expectedCreateTime = getAdditionalFieldFromResponse(resp, "creationTimeUnix"); - String expectedUpdateTime = getAdditionalFieldFromResponse(resp, "lastUpdateTimeUnix"); - WhereArgument createTimeFilter = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "_creationTimeUnix" }) - .operator(Operator.Equal) - .valueText(expectedCreateTime) - .build()) - .build(); - WhereArgument updateTimeFilter = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "_lastUpdateTimeUnix" }) - .operator(Operator.Equal) - .valueText(expectedCreateTime) - .build()) - .build(); - // when - Result createTimeResult = client.graphQL().get() - .withClassName("Pizza") - .withWhere(createTimeFilter) - .withFields(additional).run(); - Result updateTimeResult = client.graphQL().get() - .withClassName("Pizza") - .withWhere(updateTimeFilter) - .withFields(additional).run(); - // then - String resultCreateTime = getAdditionalFieldFromResponse(createTimeResult.getResult(), "creationTimeUnix"); - assertEquals(expectedCreateTime, resultCreateTime); - String resultUpdateTime = getAdditionalFieldFromResponse(updateTimeResult.getResult(), "lastUpdateTimeUnix"); - assertEquals(expectedUpdateTime, resultUpdateTime); - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testGraphQLGetUsingCursorAPI() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Pizza").withAfter("00000000-0000-0000-0000-000000000000").withLimit(10).withFields(name) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - assertEquals(3, getPizza.size()); - } - - @Test - public void testGraphQLGetUsingLimitAndOffset() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - // when - testGenerics.createTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Pizza").withOffset(3).withLimit(4).withFields(name) - .run(); - testGenerics.cleanupWeaviate(client); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - assertEquals(1, getPizza.size()); - } - - @Test - @Ignore("turned off as openai seems to be quite unstable") - public void shouldRunGenerativeSearchWithSingleResult() { - assumeTrue("OpenAI Api Key has to be configured to run the test", StringUtils.isNotBlank(openAIApiKey)); - - // given - WeaviateClient client = createClientWithOpenAIHeader(); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - Field name = Field.builder().name("name").build(); - GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder() - .singleResultPrompt("Describe this pizza : {name}") - .build(); - - // when - Result result = client.graphQL().get() - .withClassName("Pizza") - .withFields(name) - .withGenerativeSearch(generativeSearch) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - List> pizzas = extractResult(result, "Pizza"); - assertThat(pizzas).hasSize(4); - for (Map pizza : pizzas) { - assertThat(pizza.get("_additional")).isNotNull().isInstanceOf(Map.class); - Map additional = (Map) pizza.get("_additional"); - - assertThat(additional.get("generate")).isNotNull().isInstanceOf(Map.class); - Map generate = (Map) additional.get("generate"); - - assertThat(generate).containsOnlyKeys("error", "singleResult"); - assertThat(generate.get("error")).isNull(); - assertThat(generate.get("singleResult")).isNotBlank(); - } - } - - @Test - @Ignore("turned off as openai seems to be quite unstable") - public void shouldRunGenerativeSearchWithGroupedResult() { - assumeTrue("OpenAI Api Key has to be configured to run the test", StringUtils.isNotBlank(openAIApiKey)); - - // given - WeaviateClient client = createClientWithOpenAIHeader(); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - Field name = Field.builder().name("name").build(); - GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder() - .groupedResultTask("Describe these pizzas") - .build(); - - // when - Result result = client.graphQL().get() - .withClassName("Pizza") - .withFields(name) - .withGenerativeSearch(generativeSearch) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - List> pizzas = extractResult(result, "Pizza"); - assertThat(pizzas).hasSize(4); - for (int i = 0; i < pizzas.size(); i++) { - Map pizza = pizzas.get(i); - - if (i == 0) { - assertThat(pizza.get("_additional")).isNotNull().isInstanceOf(Map.class); - Map additional = (Map) pizza.get("_additional"); - - assertThat(additional.get("generate")).isNotNull().isInstanceOf(Map.class); - Map generate = (Map) additional.get("generate"); - - assertThat(generate).containsOnlyKeys("error", "groupedResult"); - assertThat(generate.get("error")).isNull(); - assertThat(generate.get("groupedResult")).isNotBlank(); - } else { - assertThat(pizza.get("_additional")).isNull(); - } - } - } - - @Test - @Ignore("turned off as openai seems to be quite unstable") - public void shouldRunGenerativeSearchWithGroupedResultAndProperties() { - assumeTrue("OpenAI Api Key has to be configured to run the test", StringUtils.isNotBlank(openAIApiKey)); - - // given - WeaviateClient client = createClientWithOpenAIHeader(); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - Field name = Field.builder().name("name").build(); - GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder() - .groupedResultTask("Describe these pizzas") - .groupedResultProperties(new String[] { "name", "description" }) - .build(); - - // when - Result result = client.graphQL().get() - .withClassName("Pizza") - .withFields(name) - .withGenerativeSearch(generativeSearch) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - List> pizzas = extractResult(result, "Pizza"); - assertThat(pizzas).hasSize(4); - for (int i = 0; i < pizzas.size(); i++) { - Map pizza = pizzas.get(i); - - if (i == 0) { - assertThat(pizza.get("_additional")).isNotNull().isInstanceOf(Map.class); - Map additional = (Map) pizza.get("_additional"); - - assertThat(additional.get("generate")).isNotNull().isInstanceOf(Map.class); - Map generate = (Map) additional.get("generate"); - - assertThat(generate).containsOnlyKeys("error", "groupedResult"); - assertThat(generate.get("error")).isNull(); - assertThat(generate.get("groupedResult")).isNotBlank(); - } else { - assertThat(pizza.get("_additional")).isNull(); - } - } - } - - @Test - @Ignore("turned off as openai seems to be quite unstable") - public void shouldRunGenerativeSearchWithBothSingleAndGroupedResults() { - assumeTrue("OpenAI Api Key has to be configured to run the test", StringUtils.isNotBlank(openAIApiKey)); - - // given - WeaviateClient client = createClientWithOpenAIHeader(); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - testGenerics.createTestSchemaAndData(client); - - Field name = Field.builder().name("name").build(); - GenerativeSearchBuilder generativeSearch = GenerativeSearchBuilder.builder() - .singleResultPrompt("Describe this pizza : {name}") - .groupedResultTask("Describe these pizzas") - .build(); - - // when - Result result = client.graphQL().get() - .withClassName("Pizza") - .withFields(name) - .withGenerativeSearch(generativeSearch) - .run(); - testGenerics.cleanupWeaviate(client); - - // then - List> pizzas = extractResult(result, "Pizza"); - assertThat(pizzas).hasSize(4); - for (int i = 0; i < pizzas.size(); i++) { - Map pizza = pizzas.get(i); - - assertThat(pizza.get("_additional")).isNotNull().isInstanceOf(Map.class); - Map additional = (Map) pizza.get("_additional"); - - assertThat(additional.get("generate")).isNotNull().isInstanceOf(Map.class); - Map generate = (Map) additional.get("generate"); - - assertThat(generate).containsOnlyKeys("error", "singleResult", "groupedResult"); - assertThat(generate.get("error")).isNull(); - assertThat(generate.get("singleResult")).isNotBlank(); - - if (i == 0) { - assertThat(generate.get("groupedResult")).isNotBlank(); - } else { - assertThat(generate.get("groupedResult")).isNull(); - } - } - } - - private WeaviateClient createClientWithOpenAIHeader() { - Map headers = new HashMap<>(); - headers.put("X-OpenAI-Api-Key", openAIApiKey); - - Config config = new Config("http", address, headers); - return new WeaviateClient(config); - } - - private void expectPizzaNamesOrder(Result result, String[] expectedPizzas) { - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizzas = (List) get.get("Pizza"); - assertEquals(expectedPizzas.length, pizzas.size()); - for (int i = 0; i < pizzas.size(); i++) { - assertPizzaName(expectedPizzas[i], pizzas, i); - } - } - - @Test - public void testGraphQLGetWithGroupBy() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - - // hits - Field[] hits = new Field[] { - Field.builder() - .name("ofDocument") - .fields(new Field[] { - Field.builder().name("... on Document") - .fields(new Field[] { Field.builder().name("_additional{id}").build() }).build() - }) - .build(), - Field.builder().name("_additional{id distance}").build(), - }; - // group - Field group = Field.builder() - .name("group") - .fields(new Field[] { - Field.builder().name("id").build(), - Field.builder().name("groupedBy") - .fields(new Field[] { - Field.builder().name("value").build(), - Field.builder().name("path").build(), - }).build(), - Field.builder().name("count").build(), - Field.builder().name("maxDistance").build(), - Field.builder().name("minDistance").build(), - Field.builder().name("hits").fields(hits).build(), - }).build(); - // _additional - Field _additional = Field.builder().name("_additional").fields(new Field[] { group }).build(); - // Property that we group by - Field ofDocument = Field.builder().name("ofDocument{__typename}").build(); - // filter arguments - GroupByArgument groupBy = client.graphQL().arguments().groupByArgBuilder() - .path(new String[] { "ofDocument" }).groups(3).objectsPerGroup(10).build(); - NearObjectArgument nearObject = client.graphQL().arguments().nearObjectArgBuilder() - .id("00000000-0000-0000-0000-000000000001").build(); - // when - testData.createAndInsertData(client); - Result groupByResult = client.graphQL().get() - .withClassName(testData.PASSAGE) - .withNearObject(nearObject) - .withGroupBy(groupBy) - .withFields(ofDocument, _additional).run(); - testData.cleanupWeaviate(client); - // then - assertThat(groupByResult).isNotNull(); - assertThat(groupByResult.getError()).isNull(); - assertThat(groupByResult.getResult()).isNotNull(); - List> result = extractResult(groupByResult, testData.PASSAGE); - assertThat(result).isNotNull().hasSize(3); - List groups = getGroups(result); - assertThat(groups).isNotNull().hasSize(3); - for (int i = 0; i < 3; i++) { - assertThat(groups.get(i).minDistance).isEqualTo(groups.get(i).getHits().get(0).get_additional().getDistance()); - assertThat(groups.get(i).maxDistance) - .isEqualTo(groups.get(i).getHits().get(groups.get(i).getHits().size() - 1).get_additional().getDistance()); - } - checkGroupElements(expectedHitsA, groups.get(0).getHits()); - checkGroupElements(expectedHitsB, groups.get(1).getHits()); - } - - @Test - public void testGraphQLGetWithGroupByWithHybrid() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - - // hits - Field[] hits = new Field[] { - Field.builder().name("content").build(), - Field.builder().name("_additional{id distance}").build(), - }; - // group - Field group = Field.builder() - .name("group") - .fields(new Field[] { - Field.builder().name("id").build(), - Field.builder().name("groupedBy") - .fields(new Field[] { - Field.builder().name("value").build(), - Field.builder().name("path").build(), - }).build(), - Field.builder().name("count").build(), - Field.builder().name("maxDistance").build(), - Field.builder().name("minDistance").build(), - Field.builder().name("hits").fields(hits).build(), - }).build(); - // _additional - Field _additional = Field.builder().name("_additional").fields(new Field[] { group }).build(); - // Property that we group by - Field content = Field.builder().name("content").build(); - // filter arguments - GroupByArgument groupBy = client.graphQL().arguments().groupByArgBuilder() - .path(new String[] { "content" }).groups(3).objectsPerGroup(10).build(); - NearTextArgument nearText = NearTextArgument.builder().concepts(new String[] { "Passage content 2" }).build(); - HybridArgument hybrid = HybridArgument.builder() - .searches(HybridArgument.Searches.builder().nearText(nearText).build()) - .query("Passage content 2") - .alpha(0.9f) - .build(); - // when - testData.createAndInsertData(client); - Result groupByResult = client.graphQL().get() - .withClassName(testData.PASSAGE) - .withHybrid(hybrid) - .withGroupBy(groupBy) - .withFields(content, _additional).run(); - testData.cleanupWeaviate(client); - // then - assertThat(groupByResult).isNotNull(); - assertThat(groupByResult.getError()).isNull(); - assertThat(groupByResult.getResult()).isNotNull(); - List> result = extractResult(groupByResult, testData.PASSAGE); - assertThat(result).isNotNull().hasSize(3); - List groups = getGroups(result); - assertThat(groups).isNotNull().hasSize(3); - for (int i = 0; i < 3; i++) { - if (i == 0) { - assertThat(groups.get(i).groupedBy.value).isEqualTo("Passage content 2"); - } - assertThat(groups.get(i).minDistance).isEqualTo(groups.get(i).getHits().get(0).get_additional().getDistance()); - assertThat(groups.get(i).maxDistance) - .isEqualTo(groups.get(i).getHits().get(groups.get(i).getHits().size() - 1).get_additional().getDistance()); - } - } - - private void assertPizzaName(String name, List pizzas, int position) { - assertTrue(pizzas.get(position) instanceof Map); - Map pizza = (Map) pizzas.get(position); - assertNotNull(pizza.get("name")); - assertEquals(name, pizza.get("name")); - } - - private void checkAggregateMetaCount(GraphQLResponse resp, int expectedResultSize, Double expectedCount) { - assertNotNull(resp); - assertNull(resp.getErrors()); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Aggregate")); - assertTrue(data.get("Aggregate") instanceof Map); - Map aggregate = (Map) data.get("Aggregate"); - assertNotNull(aggregate.get("Pizza")); - assertTrue(aggregate.get("Pizza") instanceof List); - List res = (List) aggregate.get("Pizza"); - assertEquals(expectedResultSize, res.size()); - assertTrue(res.get(0) instanceof Map); - Map count = (Map) res.get(0); - assertNotNull(count.get("meta")); - assertTrue(count.get("meta") instanceof Map); - Map countVal = (Map) count.get("meta"); - assertEquals(expectedCount, countVal.get("count")); - } - - private List> extractResult(Result result, String className) { - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get(className)); - assertTrue(get.get(className) instanceof List); - return (List) get.get(className); - } - - private void assertWhereResultSize(int expectedSize, Result result, String className) { - List getClass = extractResult(result, className); - assertEquals(expectedSize, getClass.size()); - } - - private Float[] getVectorFromResponse(GraphQLResponse resp) { - assertNotNull(resp); - assertNull(resp.getErrors()); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizza = (List) get.get("Pizza"); - assertTrue(pizza.get(0) instanceof Map); - Map firstPizza = (Map) pizza.get(0); - Map additional = (Map) firstPizza.get("_additional"); - - ArrayList vec = (ArrayList) additional.get("vector"); - Float[] res = new Float[vec.size()]; - for (int i = 0; i < vec.size(); i++) { - res[i] = ((Double) vec.get(i)).floatValue(); - } - - return res; - } - - private String getAdditionalFieldFromResponse(GraphQLResponse resp, String fieldName) { - assertNotNull(resp); - assertNull(resp.getErrors()); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List pizza = (List) get.get("Pizza"); - assertTrue(pizza.get(0) instanceof Map); - Map firstPizza = (Map) pizza.get(0); - Map additional = (Map) firstPizza.get("_additional"); - String targetField = (String) additional.get(fieldName); - return targetField; - } - - @Test - public void shouldSupportSearchByUUID() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - - String className = "ClassUUID"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("class with uuid properties") - .properties(Arrays.asList( - Property.builder() - .dataType(Collections.singletonList(DataType.UUID)) - .name("uuidProp") - .build(), - Property.builder() - .dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .name("uuidArrayProp") - .build())) - .build(); - - String id = "abefd256-8574-442b-9293-9205193737ee"; - Map properties = new HashMap<>(); - properties.put("uuidProp", "7aaa79d3-a564-45db-8fa8-c49e20b8a39a"); - properties.put("uuidArrayProp", new String[] { - "f70512a3-26cb-4ae4-9369-204555917f15", - "9e516f40-fd54-4083-a476-f4675b2b5f92" - }); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result objectStatus = client.data().creator() - .withClassName(className) - .withID(id) - .withProperties(properties) - .run(); - - assertThat(objectStatus).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - Field fieldId = Field.builder() - .name("_additional") - .fields(Field.builder().name("id").build()) - .build(); - WhereArgument whereUuid = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "uuidProp" }) - .operator(Operator.Equal) - .valueText("7aaa79d3-a564-45db-8fa8-c49e20b8a39a") - .build()) - .build(); - WhereArgument whereUuidArray1 = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "uuidArrayProp" }) - .operator(Operator.Equal) - .valueText("f70512a3-26cb-4ae4-9369-204555917f15") - .build()) - .build(); - WhereArgument whereUuidArray2 = WhereArgument.builder() - .filter(WhereFilter.builder() - .path(new String[] { "uuidArrayProp" }) - .operator(Operator.Equal) - .valueText("9e516f40-fd54-4083-a476-f4675b2b5f92") - .build()) - .build(); - - Result resultUuid = client.graphQL().get() - .withWhere(whereUuid) - .withClassName(className) - .withFields(fieldId) - .run(); - Result resultUuidArray1 = client.graphQL().get() - .withWhere(whereUuidArray1) - .withClassName(className) - .withFields(fieldId) - .run(); - Result resultUuidArray2 = client.graphQL().get() - .withWhere(whereUuidArray2) - .withClassName(className) - .withFields(fieldId) - .run(); - - assertIds(className, resultUuid, new String[] { id }); - assertIds(className, resultUuidArray1, new String[] { id }); - assertIds(className, resultUuidArray2, new String[] { id }); - - Result deleteStatus = client.schema().allDeleter().run(); - - assertThat(deleteStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - @Test - public void shouldSupportSearchWithContains() { - WeaviateClient client = new WeaviateClient(new Config("http", address)); - String className = "ContainsClass"; - - Result createResult = client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("bool") - .dataType(Collections.singletonList(DataType.BOOLEAN)) - .build(), - Property.builder() - .name("bools") - .dataType(Collections.singletonList(DataType.BOOLEAN_ARRAY)) - .build(), - - Property.builder() - .name("int") - .dataType(Collections.singletonList(DataType.INT)) - .build(), - Property.builder() - .name("ints") - .dataType(Collections.singletonList(DataType.INT_ARRAY)) - .build(), - - Property.builder() - .name("number") - .dataType(Collections.singletonList(DataType.NUMBER)) - .build(), - Property.builder() - .name("numbers") - .dataType(Collections.singletonList(DataType.NUMBER_ARRAY)) - .build(), - - Property.builder() - .name("string") - .dataType(Collections.singletonList(DataType.STRING)) - .build(), - Property.builder() - .name("strings") - .dataType(Collections.singletonList(DataType.STRING_ARRAY)) - .build(), - - Property.builder() - .name("text") - .dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder() - .name("texts") - .dataType(Collections.singletonList(DataType.TEXT_ARRAY)) - .build(), - - Property.builder() - .name("date") - .dataType(Collections.singletonList(DataType.DATE)) - .build(), - Property.builder() - .name("dates") - .dataType(Collections.singletonList(DataType.DATE_ARRAY)) - .build(), - - Property.builder() - .name("uuid") - .dataType(Collections.singletonList(DataType.UUID)) - .build(), - Property.builder() - .name("uuids") - .dataType(Collections.singletonList(DataType.UUID_ARRAY)) - .build())) - .build()) - .run(); - - assertThat(createResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - String id1 = "00000000-0000-0000-0000-000000000001"; - String id2 = "00000000-0000-0000-0000-000000000002"; - String id3 = "00000000-0000-0000-0000-000000000003"; - - TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC)); - Calendar cal1 = Calendar.getInstance(); - cal1.set(2023, Calendar.JANUARY, 15, 17, 1, 2); - Date date1 = cal1.getTime(); - Calendar cal2 = Calendar.getInstance(); - cal2.set(2023, Calendar.FEBRUARY, 15, 17, 1, 2); - Date date2 = cal2.getTime(); - Calendar cal3 = Calendar.getInstance(); - cal3.set(2023, Calendar.MARCH, 15, 17, 1, 2); - Date date3 = cal3.getTime(); - - String[] ids = new String[] { - id1, id2, id3 - }; - Boolean[] bools = new Boolean[] { - true, false, true - }; - Boolean[][] boolsArray = new Boolean[][] { - { true, false, true }, - { true, false }, - { true }, - }; - Integer[] ints = new Integer[] { - 1, 2, 3 - }; - Integer[][] intsArray = new Integer[][] { - { 1, 2, 3 }, - { 1, 2 }, - { 1 }, - }; - Double[] numbers = new Double[] { - 1.1, 2.2, 3.3 - }; - Double[][] numbersArray = new Double[][] { - { 1.1, 2.2, 3.3 }, - { 1.1, 2.2 }, - { 1.1 }, - }; - String[] strings = new String[] { - "string1", "string2", "string3" - }; - String[][] stringsArray = new String[][] { - { "string1", "string2", "string3" }, - { "string1", "string2" }, - { "string1" }, - }; - String[] texts = new String[] { - "text1", "text2", "text3" - }; - String[][] textsArray = new String[][] { - { "text1", "text2", "text3" }, - { "text1", "text2" }, - { "text1" }, - }; - Date[] dates = new Date[] { - date1, date2, date3 - }; - Date[][] datesArray = new Date[][] { - { date1, date2, date3 }, - { date1, date2 }, - { date1 }, - }; - String[] uuids = new String[] { - id1, id2, id3 - }; - String[][] uuidsArray = new String[][] { - { id1, id2, id3 }, - { id1, id2 }, - { id1 }, - }; - - Function formatDate = date -> DateFormatUtils.format(date, "yyyy-MM-dd'T'HH:mm:ssZZZZZ"); - - WeaviateObject[] objects = IntStream.range(0, ids.length).mapToObj(i -> { - Map props = new HashMap<>(); - props.put("bool", bools[i]); - props.put("bools", boolsArray[i]); - props.put("int", ints[i]); - props.put("ints", intsArray[i]); - props.put("number", numbers[i]); - props.put("numbers", numbersArray[i]); - props.put("string", strings[i]); - props.put("strings", stringsArray[i]); - props.put("text", texts[i]); - props.put("texts", textsArray[i]); - props.put("date", formatDate.apply(dates[i])); - props.put("dates", Arrays.stream(datesArray[i]).map(formatDate).toArray(String[]::new)); - props.put("uuid", uuids[i]); - props.put("uuids", uuidsArray[i]); - - return WeaviateObject.builder() - .className(className) - .id(ids[i]) - .properties(props) - .build(); - }).toArray(WeaviateObject[]::new); - - Result batchResult = client.batch().objectsBatcher() - .withObjects(objects) - .run(); - - assertBatchSuccessful(objects, batchResult); - - BiConsumer runAndAssertExpectedIds = (filter, expectedIds) -> { - Result gqlResult = client.graphQL().get() - .withClassName(className) - .withWhere(WhereArgument.builder().filter(filter).build()) - .withFields(Field.builder() - .name("_additional") - .fields(Field.builder().name("id").build()) - .build(), - Field.builder().name("bool").build(), - Field.builder().name("bools").build()) - .run(); - - assertIds(className, gqlResult, expectedIds); - }; - - // FIXME: 0 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAll).valueBoolean(boolsArray[0]).build(), - // new String[]{id1, id2}); - // FIXME: 0 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAll).valueBoolean(boolsArray[1]).build(), - // new String[]{id1, id2}); - // FIXME: 1 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAll).valueBoolean(boolsArray[2]).build(), - // new String[]{id1, id2, id3}); - // FIXME: 1 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAny).valueBoolean(boolsArray[0]).build(), - // new String[]{id1, id2, id3}); - // FIXME: 1 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAny).valueBoolean(boolsArray[1]).build(), - // new String[]{id1, id2, id3}); - // FIXME: 1 returned - // runAndAssertExpectedIds.accept( - // WhereFilter.builder().path("bools").operator(Operator.ContainsAny).valueBoolean(boolsArray[2]).build(), - // new String[]{id1, id2, id3}); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAll).valueInt(intsArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAll).valueInt(intsArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAll).valueInt(intsArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAny).valueInt(intsArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAny).valueInt(intsArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("ints").operator(Operator.ContainsAny).valueInt(intsArray[2]).build(), - new String[] { id1, id2, id3 }); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAll).valueNumber(numbersArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAll).valueNumber(numbersArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAll).valueNumber(numbersArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAny).valueNumber(numbersArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAny).valueNumber(numbersArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("numbers").operator(Operator.ContainsAny).valueNumber(numbersArray[2]).build(), - new String[] { id1, id2, id3 }); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAll).valueString(stringsArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAll).valueString(stringsArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAll).valueString(stringsArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAny).valueString(stringsArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAny).valueString(stringsArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("strings").operator(Operator.ContainsAny).valueString(stringsArray[2]).build(), - new String[] { id1, id2, id3 }); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAll).valueText(textsArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAll).valueText(textsArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAll).valueText(textsArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAny).valueText(textsArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAny).valueText(textsArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("texts").operator(Operator.ContainsAny).valueText(textsArray[2]).build(), - new String[] { id1, id2, id3 }); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAll).valueDate(datesArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAll).valueDate(datesArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAll).valueDate(datesArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAny).valueDate(datesArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAny).valueDate(datesArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("dates").operator(Operator.ContainsAny).valueDate(datesArray[2]).build(), - new String[] { id1, id2, id3 }); - - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAll).valueText(uuidsArray[0]).build(), - new String[] { id1 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAll).valueText(uuidsArray[1]).build(), - new String[] { id1, id2 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAll).valueText(uuidsArray[2]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAny).valueText(uuidsArray[0]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAny).valueText(uuidsArray[1]).build(), - new String[] { id1, id2, id3 }); - runAndAssertExpectedIds.accept( - WhereFilter.builder().path("uuids").operator(Operator.ContainsAny).valueText(uuidsArray[2]).build(), - new String[] { id1, id2, id3 }); - } - - protected void assertIds(String className, Result gqlResult, String[] expectedIds) { - assertThat(gqlResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).isInstanceOf(List.class).asList() - .hasSize(expectedIds.length); - - List> results = (List>) ((Map) (((Map) (gqlResult - .getResult().getData())).get( - "Get"))) - .get(className); - String[] resultIds = results.stream() - .map(m -> m.get("_additional")) - .map(a -> ((Map) a).get("id")) - .toArray(String[]::new); - - assertThat(resultIds).containsExactlyInAnyOrder(expectedIds); - } - - private void assertBatchSuccessful(WeaviateObject[] objects, Result batchResult) { - assertThat(batchResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(objects.length); - Arrays.stream(batchResult.getResult()).forEach(resp -> assertThat(resp).isNotNull() - .extracting(ObjectGetResponse::getResult) - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus)); - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTypedTest.java b/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTypedTest.java deleted file mode 100644 index 9835f258c..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/ClientGraphQLTypedTest.java +++ /dev/null @@ -1,46 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.tests.graphql.ClientGraphQLTypedTestSuite; -import java.util.function.Supplier; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientGraphQLTypedTest { - private WeaviateClient client; - private final WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics.createTestSchemaAndData(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testGraphQLGet() { - Supplier>> supplyPizza = () -> client.graphQL().get() - .withClassName("Pizza") - .withFields(Field.builder().name("name").build(), Field.builder().name("description").build()) - .run(ClientGraphQLTypedTestSuite.Pizzas.class); - ClientGraphQLTypedTestSuite.testGraphQLGet(supplyPizza); - } -} diff --git a/src/test/java/io/weaviate/integration/client/graphql/ClusterGraphQLTest.java b/src/test/java/io/weaviate/integration/client/graphql/ClusterGraphQLTest.java deleted file mode 100644 index 3b1cc5b64..000000000 --- a/src/test/java/io/weaviate/integration/client/graphql/ClusterGraphQLTest.java +++ /dev/null @@ -1,151 +0,0 @@ -package io.weaviate.integration.client.graphql; - -import com.google.gson.internal.LinkedTreeMap; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.integration.client.WeaviateDockerComposeCluster; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.List; -import java.util.Map; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClusterGraphQLTest { - private String address; - - @ClassRule - public static WeaviateDockerComposeCluster compose = new WeaviateDockerComposeCluster(); - - @Before - public void before() { - address = compose.getHttpHost0Address(); - } - - @Test - public void testGraphQLGetUsingConsistencyLevelAll() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[]{Field.builder().name("isConsistent").build()}) - .build(); - // when - testGenerics.createReplicatedTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Pizza").withConsistencyLevel(ConsistencyLevel.ALL) - .withFields(name, _additional) - .run(); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - for (Object pizza : getPizza) { - LinkedTreeMap pizzaMap = (LinkedTreeMap) pizza; - LinkedTreeMap additional = (LinkedTreeMap) pizzaMap.get("_additional"); - assertTrue((boolean) additional.get("isConsistent")); - } - - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testGraphQLGetUsingConsistencyLevelQuorum() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[]{Field.builder().name("isConsistent").build()}) - .build(); - // when - testGenerics.createReplicatedTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Pizza").withConsistencyLevel(ConsistencyLevel.QUORUM) - .withFields(name, _additional) - .run(); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - for (Object pizza : getPizza) { - LinkedTreeMap pizzaMap = (LinkedTreeMap) pizza; - LinkedTreeMap additional = (LinkedTreeMap) pizzaMap.get("_additional"); - assertTrue((boolean) additional.get("isConsistent")); - } - - testGenerics.cleanupWeaviate(client); - } - - @Test - public void testGraphQLGetUsingConsistencyLevelOne() { - // given - Config config = new Config("http", address); - WeaviateClient client = new WeaviateClient(config); - WeaviateTestGenerics testGenerics = new WeaviateTestGenerics(); - Field name = Field.builder().name("name").build(); - Field _additional = Field.builder() - .name("_additional") - .fields(new Field[]{Field.builder().name("isConsistent").build()}) - .build(); - // when - testGenerics.createReplicatedTestSchemaAndData(client); - Result result = client.graphQL().get() - .withClassName("Pizza").withConsistencyLevel(ConsistencyLevel.ONE) - .withFields(name, _additional) - .run(); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLResponse resp = result.getResult(); - assertNotNull(resp); - assertNotNull(resp.getData()); - assertTrue(resp.getData() instanceof Map); - Map data = (Map) resp.getData(); - assertNotNull(data.get("Get")); - assertTrue(data.get("Get") instanceof Map); - Map get = (Map) data.get("Get"); - assertNotNull(get.get("Pizza")); - assertTrue(get.get("Pizza") instanceof List); - List getPizza = (List) get.get("Pizza"); - for (Object pizza : getPizza) { - LinkedTreeMap pizzaMap = (LinkedTreeMap) pizza; - LinkedTreeMap additional = (LinkedTreeMap) pizzaMap.get("_additional"); - assertTrue((boolean) additional.get("isConsistent")); - } - - testGenerics.cleanupWeaviate(client); - } -} diff --git a/src/test/java/io/weaviate/integration/client/groups/ClientGroupsTest.java b/src/test/java/io/weaviate/integration/client/groups/ClientGroupsTest.java deleted file mode 100644 index 1b695bd17..000000000 --- a/src/test/java/io/weaviate/integration/client/groups/ClientGroupsTest.java +++ /dev/null @@ -1,45 +0,0 @@ -package io.weaviate.integration.client.groups; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.groups.Groups; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.integration.client.rbac.ClientRbacTest; -import io.weaviate.integration.tests.groups.ClientGroupsTestSuite; - -public class ClientGroupsTest extends ClientRbacTest implements ClientGroupsTestSuite.Oidc { - private final Groups groups; - - public ClientGroupsTest(Config config, String apiKey) { - super(config, apiKey); - try { - this.groups = WeaviateAuthClient.apiKey(config, apiKey).groups(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - @Override - public Result> getAssignedRoles(String groupId) { - return groups.oidc().assignedRolesGetter().withGroupId(groupId).run(); - } - - @Override - public Result> getKnownGroupNames() { - return groups.oidc().knownGroupNamesGetter().run(); - } - - @Override - public Result assignRoles(String groupId, String... roles) { - return groups.oidc().roleAssigner().withGroupId(groupId).witRoles(roles).run(); - } - - @Override - public Result revokeRoles(String groupId, String... roles) { - return groups.oidc().roleRevoker().withGroupId(groupId).witRoles(roles).run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/grpc/GRPCBenchTest.java b/src/test/java/io/weaviate/integration/client/grpc/GRPCBenchTest.java deleted file mode 100644 index 90abba6cd..000000000 --- a/src/test/java/io/weaviate/integration/client/grpc/GRPCBenchTest.java +++ /dev/null @@ -1,428 +0,0 @@ -package io.weaviate.integration.client.grpc; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.time.Instant; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Random; -import java.util.function.Function; - -import org.apache.commons.lang3.ArrayUtils; -import org.apache.commons.lang3.time.DateFormatUtils; -import org.apache.commons.lang3.time.DateUtils; -import org.assertj.core.api.Assertions; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.api.ObjectsBatcher; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.experimental.Batcher; -import io.weaviate.client.v1.experimental.Collection; -import io.weaviate.client.v1.experimental.MetadataField; -import io.weaviate.client.v1.experimental.Operand; -import io.weaviate.client.v1.experimental.SearchResult; -import io.weaviate.client.v1.experimental.Where; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.graphql.query.argument.NearVectorArgument; -import io.weaviate.client.v1.graphql.query.argument.WhereArgument; -import io.weaviate.client.v1.graphql.query.builder.GetBuilder; -import io.weaviate.client.v1.graphql.query.fields.Field; -import io.weaviate.client.v1.graphql.query.fields.Fields; -import io.weaviate.integration.client.WeaviateDockerCompose; -import lombok.AllArgsConstructor; -import lombok.ToString; - -public class GRPCBenchTest { - @ClassRule - public static final WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - private static final Random rand = new Random(); - - private WeaviateClient client; - - private static final String[] returnProperties = { "title", "price", "bestBefore", "possiblyNull" }; - private static final String className = "Things"; - private static final Date NOW = Date.from(Instant.now()); - - private static final int K = 10; - private static final String[] notIngredients = { "ketchup", "mayo" }; - private static final Map notEqualFilters = new HashMap() { - { - this.put("title", "SomeThing"); - this.put("price", 8); - this.put("bestBefore", DateUtils.addDays(NOW, 5)); - } - }; - private static final Map arrayListFilters = new HashMap() { - { - this.put("ingredientsList", Arrays.asList(notIngredients)); - this.put("ingredientsArray", notIngredients); - } - }; - - private static final int DATASET_SIZE = 30; - private static final int VECTOR_LEN = 5000; - private static final float VECTOR_ORIGIN = .0001f; - private static final float VECTOR_BOUND = .001f; - private static final List testData = new ArrayList<>(DATASET_SIZE); - private static final Float[] queryVector = new Float[VECTOR_LEN]; - - private static final int WARMUP_ROUNDS = 3; - private static final int BENCHMARK_ROUNDS = 10; - - @BeforeClass - public static void beforeAll() { - for (int i = 0; i < DATASET_SIZE; i++) { - testData.add(genVector(VECTOR_LEN, VECTOR_ORIGIN, VECTOR_BOUND)); - } - - // Query random vector from the dataset. - int randomIdx = Math.abs(rand.nextInt()) % DATASET_SIZE; - Float[] randomVector = testData.get(randomIdx); - System.arraycopy(randomVector, 0, queryVector, 0, VECTOR_LEN); - - System.out.printf("Dataset size (n. vectors): %d\n", DATASET_SIZE); - System.out.printf("Vectors with length: %d in range %.4f-%.4f\n", VECTOR_LEN, VECTOR_ORIGIN, VECTOR_BOUND); - System.out.printf("Search vector #%d\n", randomIdx); - System.out.println("==========================================="); - } - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress(), false, compose.getGrpcHostAddress()); - client = new WeaviateClient(config); - - assertTrue(dropSchema(), "successfully dropped schema"); - assertTrue(writeORM(testData), "loaded test data successfully"); - } - - @Test - public void testGraphQL() { - bench("GraphQL", () -> { - int count = searchKNN(queryVector, K, notEqualFilters, builder -> { - Result result = client - .graphQL().raw() - .withQuery(builder.build().buildQuery()) - .run(); - - if (result.getResult() == null || result.getResult().getErrors() != null) { - return 0; - } - return convertGraphQL(result); - }); - - assertEquals(K, count, String.format("must return K=%d results", K)); - }, WARMUP_ROUNDS, BENCHMARK_ROUNDS); - } - - @Test - public void testGRPC() { - bench("GRPC", () -> { - int count = searchKNN(queryVector, K, notEqualFilters, builder -> { - SearchResult> result = client - .gRPC().raw() - .withSearch(builder.build().buildSearchRequest()) - .run(); - - return countGRPC(result); - }); - - assertEquals(K, count, String.format("must return K=%d results", K)); - }, WARMUP_ROUNDS, BENCHMARK_ROUNDS); - } - - @Test - public void testNewClient() { - final float[] vector = ArrayUtils.toPrimitive(queryVector); - final Collection things = client.collections.use(className, Map.class); - bench("GRPC.new", () -> { - SearchResult> result = things.query.nearVectorUntyped( - vector, - opt -> opt - .limit(K) - .returnProperties(returnProperties) // Optional: skip this field to retrieve ALL properties - .returnMetadata(MetadataField.ID, MetadataField.VECTOR, MetadataField.DISTANCE)); - - int count = countGRPC(result); - assertEquals(K, count, String.format("must return K=%d results", K)); - }, WARMUP_ROUNDS, BENCHMARK_ROUNDS); - } - - @AllArgsConstructor - @ToString - public static class Thing { - public String title; - public Double price; - public Date bestBefore; - - public String[] ingredientsArray = {}; - // WARN: this is to test filtering with List values. Creating List - // properties is not supported in this version. - public String[] ingredientsList = {}; - - // Property containing null values. - public String possiblyNull; - } - - @Test - public void testORMClient() { - final float[] vector = ArrayUtils.toPrimitive(queryVector); - bench("GRPC.orm", () -> { - Collection things = client.collections.use(className, Thing.class); - - SearchResult result = things.query.nearVector( - vector, - opt -> opt - .limit(K) - .returnProperties(returnProperties) - .returnMetadata(MetadataField.ID, MetadataField.VECTOR, MetadataField.DISTANCE)); - - int count = countGRPC(result); - assertEquals(K, count, String.format("must return K=%d results", K)); - - Assertions.assertThat(result.objects).allSatisfy( - object -> { - Assertions.assertThat(object.metadata.id) - .isNotNull().as("must retrieve id"); - Assertions.assertThat(object.metadata.vector) - .isNotNull().as("must retrieve vector") - .hasSize(VECTOR_LEN).as("vector has expected size"); - }); - - }, WARMUP_ROUNDS, BENCHMARK_ROUNDS); - } - - @Test - public void testORMClientMapFilter() { - final float[] vector = ArrayUtils.toPrimitive(queryVector); - bench("GRPC.map-filter", () -> { - Collection things = client.collections.use(className, Thing.class); - - SearchResult result = things.query.nearVector( - vector, - opt -> opt - .limit(K) - .where(Where.or( - // Constructed from a Map! - Where.and(notEqualFilters, Where.Operator.NOT_EQUAL), - Where.and(arrayListFilters, Where.Operator.CONTAINS_ALL))) - .returnProperties(returnProperties) - .returnMetadata(MetadataField.ID, MetadataField.VECTOR, MetadataField.DISTANCE)); - - int count = countGRPC(result); - assertEquals(K, count, String.format("must return K=%d results", K)); - - // Check that filtering works - assertFalse(result.objects.stream().anyMatch(obj -> obj.properties.title.equals(notEqualFilters.get("title"))), - "expected title to not be in result set: " + notEqualFilters.get("title")); - - assertFalse(result.objects.stream().anyMatch(obj -> obj.properties.price.equals(notEqualFilters.get("price"))), - "expected price to not be in result set: " + notEqualFilters.get("price")); - }, WARMUP_ROUNDS, BENCHMARK_ROUNDS); - } - - public void exampleORMWithHardcodedFilters() { - final float[] vector = ArrayUtils.toPrimitive(queryVector); - Operand[] whereFilters = { - Where.property("title").eq("Thing A"), - Where.property("price").gte(1.94f), - Where.or( - Where.property("bestBefore").lte(Date.from(Instant.now())), - Where.property("bestBefore").ne(Date.from(Instant.now().plusSeconds(20)))), - }; - - Collection things = client.collections.use(className, Thing.class); - things.query.nearVector( - vector, - opt -> opt - .limit(K) - .where(Where.and(whereFilters)) - // .where(Where.and()) -> ignored, because no filters are applied - .returnProperties(returnProperties) - .returnMetadata(MetadataField.ID, MetadataField.VECTOR, MetadataField.DISTANCE)); - } - - private void bench(String label, Runnable test, int warmupRounds, int benchmarkRounds) { - long start = System.nanoTime(); - - // Warmup rounds to let JVM optimise execution. - // --------------------------------------- - long startWarm = start; - for (int i = 0; i < warmupRounds; i++) { - test.run(); - } - long finishWarm = System.nanoTime(); - double elapsedWarmNano = (finishWarm - startWarm) / 1000_000L; - double avgWarm = elapsedWarmNano / warmupRounds; - - // Benchmarking: measure total time and divide by the number of live rounds. - // --------------------------------------- - long startBench = System.nanoTime(); - for (int i = 0; i < benchmarkRounds; i++) { - test.run(); - } - long finishBench = System.nanoTime(); - long finish = finishBench; - - double elapsedBench = (finishBench - startBench) / 1000_000L; - double avgBench = elapsedBench / benchmarkRounds; - - double elapsed = (finish - start) / 1000_000L; - - // Print results - // --------------------------------------- - - System.out.printf("%s\t(%d warmup, %d benchmark): \u001B[1m%.2fms\033[0m\n", - label, warmupRounds, benchmarkRounds, avgBench); - System.out.printf("\twarmup.round: %.2fms", avgWarm); - System.out.printf("\t total: %.2fms\n", elapsed); - } - - private int searchKNN(Float[] query, int k, - Map filter, Function search) { - - NearVectorArgument nearVector = NearVectorArgument.builder().vector(query).build(); - - Field[] fields = new Field[returnProperties.length + 1]; - for (int i = 0; i < returnProperties.length; i++) { - fields[i] = Field.builder().name(returnProperties[i]).build(); - } - - Field additional = Field.builder().name("_additional").fields(new Field[] { - Field.builder().name("id").build(), - Field.builder().name("vector").build(), - Field.builder().name("distance").build() - }).build(); - fields[returnProperties.length] = additional; - - final GetBuilder.GetBuilderBuilder builder = GetBuilder.builder() - .className(className) - .withNearVectorFilter(nearVector) - .fields(Fields.builder().fields(fields).build()) - .limit(k); - - if (filter != null && !filter.isEmpty()) { - WhereFilter.WhereFilterBuilder where = WhereFilter.builder(); - - List operands = new ArrayList<>(); - for (String key : filter.keySet()) { - Object filterValue = filter.get(key); - if (!(filterValue instanceof String)) { - continue; // This method only supports filtering on strings. - } - WhereFilter wf = WhereFilter.builder().operator(Operator.NotEqual) - .valueString((String) filter.get(key)) - .path(key).build(); - operands.add(wf); - } - where.operands(operands.toArray(new WhereFilter[operands.size()])); - where.operator(Operator.And); - WhereArgument arg = WhereArgument.builder().filter(where.build()).build(); - builder.withWhereFilter(arg); - } - - return search.apply(builder); - } - - /* Count the number of results in the GraphQL result. */ - @SuppressWarnings("unchecked") - private int convertGraphQL(Result result) { - final Map> data = (Map>) result.getResult().getData(); - List> list = (List>) data.get("Get").get(className); - return list.size(); - } - - /* Count the number of results in the gRPC result. */ - private int countGRPC(Result>> result) { - return result.getResult().size(); - } - - /* Count the number of results in the mapped gRPC result. */ - private int countGRPC(SearchResult result) { - return result.objects.size(); - } - - private boolean dropSchema() { - return !client.schema().allDeleter().run().hasErrors(); - } - - private boolean write(List embeddings) { - ObjectsBatcher batcher = client.batch().objectsBatcher(); - int count = 0; - for (Float[] e : embeddings) { - int i = count++; - String[] ingr = mixIngredients(); - batcher.withObject(WeaviateObject.builder() - .className(className) - .vector(e) - .properties(new HashMap() { - { - this.put("title", "Thing-" + String.valueOf(i)); - this.put("price", i); - this.put("bestBefore", DateFormatUtils.format(DateUtils.addDays(NOW, i), "yyyy-MM-dd'T'HH:mm:ssZZZZZ")); - this.put("ingredientsArray", ingr); - this.put("ingredientsList", ingr); - } - }) - // .id(getUuid(e)) -> use generated UUID - .build()); - } - final Result run = batcher.run(); - batcher.close(); - - return !run.hasErrors(); - } - - /** writeORM creates {@link Thing} objects and inserts them in a batch. */ - private boolean writeORM(List embeddings) { - try (Batcher batch = client.datax.batch(Thing.class)) { - String[] ingr = mixIngredients(); - return batch.insert(b -> { - int i = 0; - for (Float[] e : embeddings) { - Thing thing = new Thing( - /* title */ "Thing-" + String.valueOf(i), - /* price */ (double) i, - - // Notice how the ORM is able to handle a raw Date object - // and convert it to the correct format behind the scenes. - /* bestBefore */ DateUtils.addDays(NOW, i), - /* ingredientsArray */ ingr, - /* ingredientsList */ ingr, - i == 2 ? "not null" : null); - b.add(thing, e); - i++; - } - }); - } - } - - /** Utility for creating random combinations of ingredients for test data. */ - private String[] mixIngredients() { - return Arrays.stream(new String[] { "milk", "honey", "butter" }) - .filter(x -> rand.nextBoolean()).toArray(String[]::new); - } - - private static Float[] genVector(int length, float origin, float bound) { - Float[] vec = new Float[length]; - for (int i = 0; i < length; i++) { - vec[i] = (Math.abs(rand.nextFloat()) % (bound - origin + 1)) + origin; - } - return vec; - } -} diff --git a/src/test/java/io/weaviate/integration/client/misc/ClientMiscTest.java b/src/test/java/io/weaviate/integration/client/misc/ClientMiscTest.java deleted file mode 100644 index ecaeef01a..000000000 --- a/src/test/java/io/weaviate/integration/client/misc/ClientMiscTest.java +++ /dev/null @@ -1,49 +0,0 @@ -package io.weaviate.integration.client.misc; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.Meta; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.misc.MiscTestSuite; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientMiscTest { - - private WeaviateClient client; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - Config config = new Config("http", compose.getHttpHostAddress()); - client = new WeaviateClient(config); - } - - @Test - public void testMiscLivenessEndpoint() { - // when - Result livenessCheck = client.misc().liveChecker().run(); - // then - MiscTestSuite.assertLivenessOrReadiness(livenessCheck); - } - - @Test - public void testMiscReadinessEndpoint() { - // when - Result readinessCheck = client.misc().readyChecker().run(); - // then - MiscTestSuite.assertLivenessOrReadiness(readinessCheck); - } - - @Test - public void testMiscMetaEndpoint() { - // when - Result meta = client.misc().metaGetter().run(); - // then - MiscTestSuite.assertMeta(meta); - } -} diff --git a/src/test/java/io/weaviate/integration/client/proxy/ClientProxyTest.java b/src/test/java/io/weaviate/integration/client/proxy/ClientProxyTest.java deleted file mode 100644 index 8a80db929..000000000 --- a/src/test/java/io/weaviate/integration/client/proxy/ClientProxyTest.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.weaviate.integration.client.proxy; - -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.testcontainers.containers.DockerComposeContainer; -import org.testcontainers.containers.wait.strategy.Wait; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.Meta; - -import java.io.File; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; - -public class ClientProxyTest { - - private WeaviateClient client; - - @ClassRule - public static DockerComposeContainer compose = new DockerComposeContainer<>( - new File("src/test/resources/docker-compose-proxy.yaml") - ).withExposedService("weaviate_1", 8080, Wait.forHttp("/v1/.well-known/ready").forStatusCode(200) - ).withExposedService("proxy_1", 80, Wait.forHttp("/").forStatusCode(503)); - - @Test - public void testProxyUnset() { - Config config = new Config("http", "weaviate.local"); - - client = new WeaviateClient(config); - // when - Result meta = client.misc().metaGetter().run(); - // then - assertNotNull(meta); - assertNotNull(meta.getError()); - } - - @Test - public void testProxySet() { - String proxyHost = compose.getServiceHost("proxy_1", 80); - Integer port = compose.getServicePort("proxy_1", 80); - String proxyScheme = "http"; - - Config config = new Config("http", "weaviate.local"); - config.setProxy(proxyHost, port, proxyScheme); - - client = new WeaviateClient(config); - // when - Result meta = client.misc().metaGetter().run(); - // then - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/rbac/ClientRbacTest.java b/src/test/java/io/weaviate/integration/client/rbac/ClientRbacTest.java deleted file mode 100644 index dfc1f2520..000000000 --- a/src/test/java/io/weaviate/integration/client/rbac/ClientRbacTest.java +++ /dev/null @@ -1,81 +0,0 @@ -package io.weaviate.integration.client.rbac; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.rbac.Roles; -import io.weaviate.client.v1.rbac.model.GroupAssignment; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.rbac.model.UserAssignment; -import io.weaviate.integration.tests.rbac.ClientRbacTestSuite; - -public class ClientRbacTest implements ClientRbacTestSuite.Rbac { - private Roles roles; - - public ClientRbacTest(Config config, String apiKey) { - try { - this.roles = WeaviateAuthClient.apiKey(config, apiKey).roles(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - @Override - public Result getRole(String role) { - return roles.getter().withName(role).run(); - } - - @Override - public Result> getAll() { - return roles.allGetter().run(); - } - - @Override - public Result> getAssignedUsers(String role) { - return roles.assignedUsersGetter().withRole(role).run(); - } - - @Override - public Result createRole(String role, Permission... permissions) { - return roles.creator().withName(role).withPermissions(permissions).run(); - } - - @Override - public void deleteRole(String role) { - roles.deleter().withName(role).run(); - } - - @Override - public Result hasPermission(String role, Permission perm) { - return roles.permissionChecker().withRole(role).withPermission(perm).run(); - } - - @Override - public Result exists(String role) { - return roles.exists().withName(role).run(); - } - - @Override - public Result addPermissions(String role, Permission... permissions) { - return roles.permissionAdder().withRole(role).withPermissions(permissions).run(); - } - - @Override - public Result removePermissions(String role, Permission... permissions) { - return roles.permissionRemover().withRole(role).withPermissions(permissions).run(); - } - - @Override - public Result> getUserAssignments(String role) { - return roles.userAssignmentsGetter().withRole(role).run(); - } - - @Override - public Result> getGroupAssignments(String role) { - return roles.groupAssignmentsGetter().withRole(role).run(); - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaDefaultsAndMigrationTest.java b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaDefaultsAndMigrationTest.java deleted file mode 100644 index 302017f6e..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaDefaultsAndMigrationTest.java +++ /dev/null @@ -1,1255 +0,0 @@ -package io.weaviate.integration.client.schema; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tokenization; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerCompose; - -import java.util.Collections; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.runner.RunWith; - -@RunWith(JParamsTestRunner.class) -public class ClientSchemaDefaultsAndMigrationTest { - private WeaviateClient client; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - } - - @After - public void after() { - Result deleted = client.schema().allDeleter().run(); - assertThat(deleted.hasErrors()).isFalse(); - } - - @DataMethod(source = ClientSchemaDefaultsAndMigrationTest.class, method = "provideForDataTypeAndTokenization") - @Test - public void shouldCreatePropertyWithDataTypeAndTokenization(String dataType, String tokenization, - String expectedDataType, String expectedTokenization) { - WeaviateClass clazz = WeaviateClass.builder() - .className("SomeClass") - .description("some class description") - .properties(Collections.singletonList(Property.builder() - .name("someProperty") - .description("some property description") - .dataType(Collections.singletonList(dataType)) - .tokenization(tokenization) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result classStatus = client.schema().classGetter() - .withClassName("SomeClass") - .run(); - - assertThat(classStatus).isNotNull() - .returns(false, Result::hasErrors); - assertThat(classStatus.getResult()).isNotNull() - .extracting(WeaviateClass::getProperties).asList() - .hasSize(1) - .first().extracting(prop -> (Property) prop) - .returns(Collections.singletonList(expectedDataType), Property::getDataType) - .returns(expectedTokenization, Property::getTokenization); - } - - public static Object[][] provideForDataTypeAndTokenization() { - return new Object[][]{ - new Object[]{ - DataType.TEXT, null, - DataType.TEXT, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT, "", - DataType.TEXT, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT, Tokenization.WORD, - DataType.TEXT, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT, Tokenization.LOWERCASE, - DataType.TEXT, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.TEXT, Tokenization.WHITESPACE, - DataType.TEXT, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.TEXT, Tokenization.FIELD, - DataType.TEXT, Tokenization.FIELD, - }, - - new Object[]{ - DataType.TEXT_ARRAY, null, - DataType.TEXT_ARRAY, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT_ARRAY, "", - DataType.TEXT_ARRAY, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT_ARRAY, Tokenization.WORD, - DataType.TEXT_ARRAY, Tokenization.WORD, - }, - new Object[]{ - DataType.TEXT_ARRAY, Tokenization.LOWERCASE, - DataType.TEXT_ARRAY, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.TEXT_ARRAY, Tokenization.WHITESPACE, - DataType.TEXT_ARRAY, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.TEXT_ARRAY, Tokenization.FIELD, - DataType.TEXT_ARRAY, Tokenization.FIELD, - }, - - new Object[]{ - DataType.STRING, null, - DataType.TEXT, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING, "", - DataType.TEXT, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING, Tokenization.WORD, - DataType.TEXT, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING, Tokenization.FIELD, - DataType.TEXT, Tokenization.FIELD, - }, - - new Object[]{ - DataType.STRING_ARRAY, null, - DataType.TEXT_ARRAY, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING_ARRAY, "", - DataType.TEXT_ARRAY, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING_ARRAY, Tokenization.WORD, - DataType.TEXT_ARRAY, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.STRING_ARRAY, Tokenization.FIELD, - DataType.TEXT_ARRAY, Tokenization.FIELD, - }, - - new Object[]{ - DataType.INT, null, - DataType.INT, null, - }, - new Object[]{ - DataType.INT, "", - DataType.INT, null, - }, - - new Object[]{ - DataType.INT_ARRAY, null, - DataType.INT_ARRAY, null, - }, - new Object[]{ - DataType.INT_ARRAY, "", - DataType.INT_ARRAY, null, - }, - }; - } - - - @DataMethod(source = ClientSchemaDefaultsAndMigrationTest.class, method = "provideInvalidForDataTypeAndTokenization") - @Test - public void shouldNotCreatePropertyWithDataTypeAndTokenization(String dataType, String tokenization) { - WeaviateClass clazz = WeaviateClass.builder() - .className("SomeClass") - .description("some class description") - .properties(Collections.singletonList(Property.builder() - .name("someProperty") - .description("some property description") - .dataType(Collections.singletonList(dataType)) - .tokenization(tokenization) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(true, Result::hasErrors) - .extracting(Result::getError) - .returns(422, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThanOrEqualTo(1) - .first().extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()).asString() - .contains("is not allowed for data type"); - } - - public static Object[][] provideInvalidForDataTypeAndTokenization() { - return new Object[][]{ - new Object[]{ - DataType.STRING, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.STRING, Tokenization.WHITESPACE, - }, - - new Object[]{ - DataType.STRING_ARRAY, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.STRING_ARRAY, Tokenization.WHITESPACE, - }, - - new Object[]{ - DataType.INT, Tokenization.WORD, - }, - new Object[]{ - DataType.INT, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.INT, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.INT, Tokenization.FIELD, - }, - - new Object[]{ - DataType.INT_ARRAY, Tokenization.WORD, - }, - new Object[]{ - DataType.INT_ARRAY, Tokenization.LOWERCASE, - }, - new Object[]{ - DataType.INT_ARRAY, Tokenization.WHITESPACE, - }, - new Object[]{ - DataType.INT_ARRAY, Tokenization.FIELD, - }, - }; - } - - - @DataMethod(source = ClientSchemaDefaultsAndMigrationTest.class, method = "provideForDataTypeAndIndexing") - @Test - public void shouldCreatePropertyWithDataTypeAndIndexing(String dataType, - Boolean inverted, Boolean expectedInverted, - Boolean filterable, Boolean expectedFilterable, - Boolean searchable, Boolean expectedSearchable, - Boolean rangeFilters, Boolean expectedRangeFilters) { - WeaviateClass clazz = WeaviateClass.builder() - .className("SomeClass") - .description("some class description") - .properties(Collections.singletonList(Property.builder() - .name("someProperty") - .description("some property description") - .dataType(Collections.singletonList(dataType)) - .indexInverted(inverted) - .indexFilterable(filterable) - .indexSearchable(searchable) - .indexRangeFilters(rangeFilters) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - Result classStatus = client.schema().classGetter() - .withClassName("SomeClass") - .run(); - - assertThat(classStatus).isNotNull() - .returns(false, Result::hasErrors); - assertThat(classStatus.getResult()).isNotNull() - .extracting(WeaviateClass::getProperties).asList() - .hasSize(1) - .first().extracting(prop -> (Property) prop) - .returns(expectedInverted, Property::getIndexInverted) - .returns(expectedFilterable, Property::getIndexFilterable) - .returns(expectedSearchable, Property::getIndexSearchable) - .returns(expectedRangeFilters, Property::getIndexRangeFilters); - } - - public static Object[][] provideForDataTypeAndIndexing() { - return new Object[][]{ - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - null, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - null, Boolean.TRUE, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, - null, Boolean.FALSE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, - null, Boolean.TRUE, - null, Boolean.TRUE, - null, Boolean.FALSE, - }, - - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - null, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - null, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - null, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - null, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.FALSE, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - null, null, - Boolean.TRUE, Boolean.TRUE, - Boolean.FALSE, Boolean.FALSE, - Boolean.TRUE, Boolean.TRUE, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, - null, Boolean.FALSE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, - null, Boolean.TRUE, - null, Boolean.FALSE, - null, Boolean.FALSE, - }, - }; - } - - - @DataMethod(source = ClientSchemaDefaultsAndMigrationTest.class, method = "provideInvalidForDataTypeAndIndexing") - @Test - public void shouldNotCreatePropertyWithDataTypeAndIndexing(String dataType, - Boolean inverted, Boolean filterable, - Boolean searchable, Boolean rangeFilters, - String expectedErrMsg) { - WeaviateClass clazz = WeaviateClass.builder() - .className("SomeClass") - .description("some class description") - .properties(Collections.singletonList(Property.builder() - .name("someProperty") - .description("some property description") - .dataType(Collections.singletonList(dataType)) - .indexInverted(inverted) - .indexFilterable(filterable) - .indexSearchable(searchable) - .indexRangeFilters(rangeFilters) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator() - .withClass(clazz) - .run(); - - assertThat(createStatus).isNotNull() - .returns(true, Result::hasErrors) - .extracting(Result::getError) - .returns(422, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThanOrEqualTo(1) - .first().extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()).asString() - .contains(expectedErrMsg); - } - - public static Object[][] provideInvalidForDataTypeAndIndexing() { - String errInverted = "`indexInverted` is deprecated and can not be set together with `indexFilterable`, `indexSearchable` or `indexRangeFilters`"; - String errSearchable = "`indexSearchable` is allowed only for text/text[] data types. For other data types set false or leave empty"; - String errRangeFilters = "`indexRangeFilters` is allowed only for number/int/date data types. For other data types set false or leave empty"; - - return new Object[][]{ - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, null, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, null, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, null, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, null, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.FALSE, null, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.TEXT, - Boolean.TRUE, null, null, Boolean.TRUE, - errInverted, - }, - - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, null, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, null, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, null, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, null, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, null, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.FALSE, null, null, Boolean.TRUE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, null, Boolean.FALSE, - errInverted, - }, - new Object[]{ - DataType.INT, - Boolean.TRUE, null, null, Boolean.TRUE, - errInverted, - }, - - new Object[]{ - DataType.INT, - null, null, Boolean.TRUE, null, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, null, Boolean.TRUE, Boolean.FALSE, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, null, Boolean.TRUE, Boolean.TRUE, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.FALSE, Boolean.TRUE, null, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.FALSE, Boolean.TRUE, Boolean.FALSE, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.TRUE, Boolean.TRUE, null, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.TRUE, Boolean.TRUE, Boolean.FALSE, - errSearchable, - }, - new Object[]{ - DataType.INT, - null, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errSearchable, - }, - - new Object[]{ - DataType.TEXT, - null, null, null, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.FALSE, null, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.TRUE, null, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, null, Boolean.FALSE, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, null, Boolean.TRUE, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.FALSE, Boolean.FALSE, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.FALSE, Boolean.TRUE, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.TRUE, Boolean.FALSE, Boolean.TRUE, - errRangeFilters, - }, - new Object[]{ - DataType.TEXT, - null, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, - errRangeFilters, - }, - }; - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaMultiTenancyTest.java b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaMultiTenancyTest.java deleted file mode 100644 index 00eae007a..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaMultiTenancyTest.java +++ /dev/null @@ -1,449 +0,0 @@ -package io.weaviate.integration.client.schema; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.MultiTenancyConfig; -import io.weaviate.client.v1.schema.model.ActivityStatus; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.AssertMultiTenancy; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_1; -import static io.weaviate.integration.client.WeaviateTestGenerics.TENANT_2; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientSchemaMultiTenancyTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - private AssertMultiTenancy assertMT; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - assertMT = new AssertMultiTenancy(client); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - - @Test - public void shouldCreateClassWithMultiTenancyConfig() { - String className = "MultiTenantClass"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .multiTenancyConfig(MultiTenancyConfig.builder() - .enabled(true) - .build()) - .properties(Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus.hasErrors()).isFalse(); - assertThat(createStatus.getResult()).isTrue(); - - Result classResult = client.schema().classGetter().withClassName(className).run(); - assertThat(classResult.hasErrors()).isFalse(); - assertThat(classResult.getResult()).isNotNull() - .extracting(WeaviateClass::getMultiTenancyConfig) - .isNotNull() - .returns(true, MultiTenancyConfig::getEnabled); - } - - @Test - public void shouldCreateClassWithMultiTenancyConfigDisabled() { - String className = "MultiTenantClassWannabe"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .multiTenancyConfig(MultiTenancyConfig.builder() - .enabled(false) - .build()) - .properties(Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build() - )) - .build(); - - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus.hasErrors()).isFalse(); - assertThat(createStatus.getResult()).isTrue(); - - Result classResult = client.schema().classGetter().withClassName(className).run(); - assertThat(classResult.hasErrors()).isFalse(); - assertThat(classResult.getResult()).isNotNull() - .extracting(WeaviateClass::getMultiTenancyConfig) - .isNotNull() - .returns(false, MultiTenancyConfig::getEnabled); - } - - @Test - public void shouldCreateClassWithoutMultiTenancyConfig() { - // given - String className = "OrdinaryClass"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .properties(Collections.singletonList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build() - )) - .build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus.hasErrors()).isFalse(); - assertThat(createStatus.getResult()).isTrue(); - - // then - Result classResult = client.schema().classGetter().withClassName(className).run(); - assertThat(classResult.hasErrors()).isFalse(); - assertThat(classResult.getResult()).isNotNull() - .extracting(WeaviateClass::getMultiTenancyConfig) - .isNotNull() - .returns(false, MultiTenancyConfig::getEnabled); - } - - @Test - public void shouldAddTenantsToMTClass() { - String[] tenants = new String[]{"TenantNo1", "TenantNo2"}; - testGenerics.createSchemaPizzaForTenants(client); - - Tenant[] tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).build()) - .toArray(Tenant[]::new); - - Result addResult = client.schema().tenantsCreator() - .withClassName("Pizza") - .withTenants(tenantObjs) - .run(); - - assertThat(addResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - for (String tenant: tenants) { - Result exists = client.schema().tenantsExists() - .withClassName("Pizza") - .withTenant(tenant) - .run(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - } - - @Test - public void shouldNotAddTenantsToNonMTClass() { - String[] tenants = new String[]{"TenantNo1", "TenantNo2"}; - testGenerics.createSchemaPizza(client); - - Tenant[] tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).build()) - .toArray(Tenant[]::new); - - Result addResult = client.schema().tenantsCreator() - .withClassName("Pizza") - .withTenants(tenantObjs) - .run(); - - assertMT.error(addResult, false, 422, "multi-tenancy is not enabled for class"); - } - - @Test - public void shouldGetTenantsFromMTClass() { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - String[] tenantNames = Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Result> getResult = client.schema().tenantsGetter() - .withClassName("Pizza") - .run(); - - assertThat(getResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(tenants.length); - - String[] fetchedTenants = getResult.getResult().stream() - .map(Tenant::getName) - .toArray(String[]::new); - assertThat(fetchedTenants).containsExactlyInAnyOrder(tenantNames); - } - - @Test - public void shouldNotGetTenantsFromNonMTClass() { - testGenerics.createSchemaPizza(client); - - Result> getResult = client.schema().tenantsGetter() - .withClassName("Pizza") - .run(); - - assertMT.error(getResult, null, 422, "multi-tenancy is not enabled for class"); - } - - @Test - public void shouldUpdateTenantsOfMTClass() { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Result updateResult = client.schema().tenantsUpdater() - .withClassName("Pizza") - .withTenants(Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant.getName()).activityStatus(ActivityStatus.COLD).build()) - .toArray(Tenant[]::new)) - .run(); - - assertThat(updateResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - @Test - public void shouldNotUpdateNonExistentTenantsOfMTClass() { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Result updateResult = client.schema().tenantsUpdater() - .withClassName("Pizza") - .withTenants(Tenant.builder().name("nonExistentTenant").activityStatus(ActivityStatus.COLD).build()) - .run(); - - assertMT.error(updateResult, false, 422, "nonExistentTenant", "not found"); - } - - @Test - public void shouldNotUpdateTenantsOfNonMTClass() { - testGenerics.createSchemaPizza(client); - - Result updateResult = client.schema().tenantsUpdater() - .withClassName("Pizza") - .withTenants( - Tenant.builder().name(TENANT_1.getName()).activityStatus(ActivityStatus.COLD).build(), - Tenant.builder().name(TENANT_2.getName()).activityStatus(ActivityStatus.COLD).build()) - .run(); - - assertMT.error(updateResult, false, 422, "multi-tenancy is not enabled for class"); - } - - @Test - public void shouldDeleteTenantsFromMTClass() { - Tenant[] tenants = new Tenant[]{TENANT_1, TENANT_2}; - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - Result deleteResult = client.schema().tenantsDeleter() - .withClassName("Pizza") - .withTenants(TENANT_1.getName(), TENANT_2.getName(), "nonExistentTenant") - .run(); - - assertThat(deleteResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - @Test - public void shouldNotDeleteTenantsFromNonMTClass() { - String[] tenants = new String[]{"TenantNo1", "TenantNo2"}; - testGenerics.createSchemaPizza(client); - - Result deleteResult = client.schema().tenantsDeleter() - .withClassName("Pizza") - .withTenants(tenants) - .run(); - - assertMT.error(deleteResult, false, 422, "multi-tenancy is not enabled for class"); - } - - @Test - public void shouldActivateDeactivateTenants() { - Tenant[] tenants = new Tenant[]{ - Tenant.builder().name("TenantNo1").build(), // default activity status (HOT) - Tenant.builder().name("TenantNo2").activityStatus(ActivityStatus.HOT).build(), - Tenant.builder().name("TenantNo3").activityStatus(ActivityStatus.COLD).build(), - }; - - String classPizza = "Pizza"; - int pizzaSize = WeaviateTestGenerics.IDS_BY_CLASS.get(classPizza).size(); - - // create tenants (1,2,3) - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenants); - - // populate active tenants (1,2) - testGenerics.createDataPizzaForTenants(client, tenants[0].getName(), tenants[1].getName()); - - assertMT.tenantActive(classPizza, tenants[0].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[0].getName(), pizzaSize); - assertMT.tenantActive(classPizza, tenants[1].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[1].getName(), pizzaSize); - assertMT.tenantInactive(classPizza, tenants[2].getName()); - assertMT.tenantInactiveGetsNoObjects(classPizza, tenants[2].getName()); - - // deactivate tenant (1) - Result result = client.schema().tenantsUpdater() - .withClassName(classPizza) - .withTenants(Tenant.builder().name(tenants[0].getName()).activityStatus(ActivityStatus.COLD).build()) - .run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - assertMT.tenantInactive(classPizza, tenants[0].getName()); - assertMT.tenantInactiveGetsNoObjects(classPizza, tenants[0].getName()); - assertMT.tenantActive(classPizza, tenants[1].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[1].getName(), pizzaSize); - assertMT.tenantInactive(classPizza, tenants[2].getName()); - assertMT.tenantInactiveGetsNoObjects(classPizza, tenants[2].getName()); - - // activate tenant (3) - Result result2 = client.schema().tenantsUpdater() - .withClassName(classPizza) - .withTenants(Tenant.builder().name(tenants[2].getName()).activityStatus(ActivityStatus.HOT).build()) - .run(); - assertThat(result2).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // populate active tenant (3) - testGenerics.createDataPizzaForTenants(client, tenants[2].getName()); - - assertMT.tenantInactive(classPizza, tenants[0].getName()); - assertMT.tenantInactiveGetsNoObjects(classPizza, tenants[0].getName()); - assertMT.tenantActive(classPizza, tenants[1].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[1].getName(), pizzaSize); - assertMT.tenantActive(classPizza, tenants[2].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[2].getName(), pizzaSize); - - // activate tenant (1) - Result result3 = client.schema().tenantsUpdater() - .withClassName(classPizza) - .withTenants(Tenant.builder().name(tenants[0].getName()).activityStatus(ActivityStatus.HOT).build()) - .run(); - assertThat(result3).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - assertMT.tenantActive(classPizza, tenants[0].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[0].getName(), pizzaSize); - assertMT.tenantActive(classPizza, tenants[1].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[1].getName(), pizzaSize); - assertMT.tenantActive(classPizza, tenants[2].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[2].getName(), pizzaSize); - - // deactivate tenant (2) - Result result4 = client.schema().tenantsUpdater() - .withClassName(classPizza) - .withTenants(Tenant.builder().name(tenants[1].getName()).activityStatus(ActivityStatus.COLD).build()) - .run(); - assertThat(result4).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - assertMT.tenantActive(classPizza, tenants[0].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[0].getName(), pizzaSize); - assertMT.tenantInactive(classPizza, tenants[1].getName()); - assertMT.tenantInactiveGetsNoObjects(classPizza, tenants[1].getName()); - assertMT.tenantActive(classPizza, tenants[2].getName()); - assertMT.tenantActiveGetsObjects(classPizza, tenants[2].getName(), pizzaSize); - - // delete tenants - Result result5 = client.schema().tenantsDeleter() - .withClassName(classPizza) - .withTenants(Arrays.stream(tenants).map(Tenant::getName).toArray(String[]::new)) - .run(); - assertThat(result5).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - @Test - public void shouldAddAndUpdateMoreThan100TenantsToMTClass() { - int numberOfTenants = 201; - String[] tenants = new String[numberOfTenants]; - for (int i = 0; i < numberOfTenants; i++) { - tenants[i] = String.format("TenantNo%s", i); - } - testGenerics.createSchemaPizzaForTenants(client); - - Tenant[] tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).build()) - .toArray(Tenant[]::new); - - Result addResult = client.schema().tenantsCreator() - .withClassName("Pizza") - .withTenants(tenantObjs) - .run(); - - assertThat(addResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - for (String tenant: tenants) { - Result exists = client.schema().tenantsExists() - .withClassName("Pizza") - .withTenant(tenant) - .run(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).activityStatus(ActivityStatus.COLD).build()) - .toArray(Tenant[]::new); - - Result updateResult = client.schema().tenantsUpdater() - .withClassName("Pizza") - .withTenants(tenantObjs) - .run(); - - assertThat(updateResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - for (String tenant: tenants) { - Result exists = client.schema().tenantsExists() - .withClassName("Pizza") - .withTenant(tenant) - .run(); - - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTenantOffloadingTest.java b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTenantOffloadingTest.java deleted file mode 100644 index 23d6d24e3..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTenantOffloadingTest.java +++ /dev/null @@ -1,141 +0,0 @@ -package io.weaviate.integration.client.schema; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.ActivityStatus; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.client.WeaviateTestGenerics; -import io.weaviate.integration.client.WeaviateVersion; -import java.util.Arrays; -import java.util.List; -import static org.assertj.core.api.Assertions.assertThat; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -public class ClientSchemaTenantOffloadingTest { - - private WeaviateClient client; - private WeaviateTestGenerics testGenerics; - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(WeaviateVersion.WEAVIATE_IMAGE, true); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - String grpcHost = compose.getGrpcHostAddress(); - Config config = new Config("http", httpHost); - config.setGRPCSecured(false); - config.setGRPCHost(grpcHost); - - client = new WeaviateClient(config); - testGenerics = new WeaviateTestGenerics(); - } - - @After - public void after() { - testGenerics.cleanupWeaviate(client); - } - - @Test - public void shouldOffloadTenants() throws InterruptedException { - // create tenants and class - String className = "Pizza"; - String[] tenants = new String[]{"Tenant1", "Tenant2", "Tenant3"}; - Tenant[] tenantObjs = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).build()) - .toArray(Tenant[]::new); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, tenantObjs); - // verify tenants existence - Result> getResult = client.schema().tenantsGetter() - .withClassName(className) - .run(); - assertThat(getResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList() - .hasSize(tenants.length); - // insert data - testGenerics.createDataPizzaForTenants(client, tenants); - // verify data existence - for (String tenant : tenants) { - Result> result = client.data().objectsGetter().withClassName(className).withTenant(tenant).run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(4); - } - // verify tenant status HOT - verifyEventuallyTenantStatus(className, ActivityStatus.HOT); - // update tenants to FROZEN - updateTenantStatus(className, tenants, ActivityStatus.FROZEN); - // verify tenant status FREEZING - verifyEventuallyTenantStatus(className, ActivityStatus.FROZEN); - // verify tenants does not exist - for (String tenant : tenants) { - Result> result = client.data().objectsGetter().withClassName(className).withTenant(tenant).run(); - assertThat(result).isNotNull() - .returns(true, Result::hasErrors) - .extracting(Result::getResult).isNull(); - } - // verify tenant status FROZEN - verifyEventuallyTenantStatus(className, ActivityStatus.FROZEN); - // updating tenant status to HOT - updateTenantStatus(className, tenants, ActivityStatus.HOT); - // verify tenant status HOT - verifyEventuallyTenantStatus(className, ActivityStatus.HOT); - // verify object creation - for (String tenant : tenants) { - Result> result = client.data().objectsGetter().withClassName(className).withTenant(tenant).run(); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(4); - } - } - - private void updateTenantStatus(String className, String[] tenants, String activityStatus) { - Tenant[] tenantsWithStatus = Arrays.stream(tenants) - .map(tenant -> Tenant.builder().name(tenant).activityStatus(activityStatus).build()) - .toArray(Tenant[]::new); - Result exists = client.schema().tenantsUpdater() - .withClassName(className) - .withTenants(tenantsWithStatus) - .run(); - assertThat(exists).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - private void verifyEventuallyTenantStatus(String className, String activityStatus) throws InterruptedException { - boolean statusOK = false; - int hardBreak = 5*60; - while(hardBreak > 0) { - if (verifyTenantStatus(className, activityStatus)) { - statusOK = true; - break; - } - Thread.sleep(1000); - hardBreak--; - } - assertThat(statusOK).isTrue(); - } - - private boolean verifyTenantStatus(String className, String activityStatus) { - Result> getResult = client.schema().tenantsGetter() - .withClassName(className) - .run(); - assertThat(getResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - for (Tenant tenant : getResult.getResult()) { - if (!tenant.getActivityStatus().equals(activityStatus)) { - return false; - } - } - return true; - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java b/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java deleted file mode 100644 index 27fb05f45..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/ClientSchemaTest.java +++ /dev/null @@ -1,1387 +0,0 @@ -package io.weaviate.integration.client.schema; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import java.io.File; -import java.io.InputStreamReader; -import java.nio.file.Files; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - -import com.google.gson.Gson; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.BM25Config; -import io.weaviate.client.v1.misc.model.DistanceType; -import io.weaviate.client.v1.misc.model.InvertedIndexConfig; -import io.weaviate.client.v1.misc.model.PQConfig; -import io.weaviate.client.v1.misc.model.ReplicationConfig; -import io.weaviate.client.v1.misc.model.ShardingConfig; -import io.weaviate.client.v1.misc.model.StopwordConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.Shard; -import io.weaviate.client.v1.schema.model.ShardStatus; -import io.weaviate.client.v1.schema.model.ShardStatuses; -import io.weaviate.client.v1.schema.model.Tokenization; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.client.v1.schema.model.WeaviateClass.VectorConfig; -import io.weaviate.integration.client.WeaviateDockerCompose; -import io.weaviate.integration.tests.schema.SchemaTestSuite; - -public class ClientSchemaTest { - private WeaviateClient client; - private final NestedObjectsUtils utils = new NestedObjectsUtils(); - - @ClassRule - public static WeaviateDockerCompose compose = new WeaviateDockerCompose(); - - @Before - public void before() { - String httpHost = compose.getHttpHostAddress(); - Config config = new Config("http", httpHost); - - client = new WeaviateClient(config); - } - - @After - public void after() { - Result deleted = client.schema().allDeleter().run(); - assertThat(deleted.hasErrors()).isFalse(); - } - - @Test - public void testSchemaCreateBandClass() { - // given - WeaviateClass clazz = SchemaTestSuite.testSchemaCreateBandClass.clazz; - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schema = client.schema().getter().run(); - // then - SchemaTestSuite.testSchemaCreateBandClass.assertResults(createStatus, schema); - } - - @Test - public void testSchemaCreateRunClass() { - // given - WeaviateClass clazz = SchemaTestSuite.testSchemaCreateRunClass.clazz; - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - SchemaTestSuite.testSchemaCreateRunClass.assertResults(createStatus, schemaAfterCreate, - deleteStatus, schemaAfterDelete); - } - - @Test - public void testSchemaDeleteClasses() { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaDeleteClasses.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteClasses.chickenSoup; - // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deletePizzaStatus = client.schema().classDeleter().withClassName(pizza.getClassName()).run(); - Result deleteChickenSoupStatus = client.schema().classDeleter().withClassName(chickenSoup.getClassName()) - .run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - SchemaTestSuite.testSchemaDeleteClasses.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, schemaAfterCreate, deletePizzaStatus, deleteChickenSoupStatus, - schemaAfterDelete); - } - - @Test - public void testSchemaDeleteAllSchema() { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaDeleteAllSchema.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaDeleteAllSchema.chickenSoup; - // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deleteAllStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - SchemaTestSuite.testSchemaDeleteAllSchema.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, schemaAfterCreate, deleteAllStatus, schemaAfterDelete); - } - - @Test - public void testSchemaCreateClassesAddProperties() { - // given - WeaviateClass pizza = SchemaTestSuite.testSchemaCreateClassesAddProperties.pizza; - WeaviateClass chickenSoup = SchemaTestSuite.testSchemaCreateClassesAddProperties.chickenSoup; - Property newProperty = SchemaTestSuite.testSchemaCreateClassesAddProperties.newProperty; - // when - Result pizzaCreateStatus = client.schema().classCreator().withClass(pizza).run(); - Result chickenSoupCreateStatus = client.schema().classCreator().withClass(chickenSoup).run(); - Result pizzaPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(pizza.getClassName()).run(); - Result chickenSoupPropertyCreateStatus = client.schema().propertyCreator() - .withProperty(newProperty).withClassName(chickenSoup.getClassName()).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deleteAllStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - // then - SchemaTestSuite.testSchemaCreateClassesAddProperties.assertResults(pizzaCreateStatus, - chickenSoupCreateStatus, pizzaPropertyCreateStatus, chickenSoupPropertyCreateStatus, - schemaAfterCreate, deleteAllStatus, schemaAfterDelete); - } - - @Test - public void testSchemaAddVectors() { - // Arrange - VectorConfig vector = VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(Collections.singletonMap("none", Collections.emptyMap())) - .vectorIndexConfig(VectorIndexConfig.builder().build()) - .build(); - String className = "Pizza_testSchemaAddVectors"; - client.schema().classCreator() - .withClass(WeaviateClass.builder() - .className(className) - .properties(Collections.singletonList( - Property.builder() - .name("title").dataType(Collections.singletonList(DataType.TEXT)) - .build())) - .vectorConfig(Collections.singletonMap("default", vector)) - .build()) - .run(); - - // Act - Result add = client.schema().vectorAdder() - .withClassName(className) - .withVectorConfig("vector-a", vector) - .withVectorConfig("vector-b", vector) - .run(); - assertNull("error adding new vectors", add.getError()); - - Result result = client.schema().classGetter().withClassName(className).run(); - WeaviateClass pizza = result.getResult(); - assertThat(pizza.getVectorConfig()) - .as("has all 3 vectors") - .containsKeys("default", "vector-a", "vector-b"); - } - - @Test - public void testSchemaCreateClassExplicitVectorizerWithArrayProperties() { - // given - WeaviateClass clazz = WeaviateClass.builder().className("ClassArrays") - .description("Class which properties are all array properties").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").properties(new ArrayList() { - { - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT_ARRAY); - } - }).name("stringArray").tokenization(Tokenization.FIELD).build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT_ARRAY); - } - }).name("textArray").tokenization(Tokenization.WORD).build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.INT_ARRAY); - } - }).name("intArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.NUMBER_ARRAY); - } - }).name("numberArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.BOOLEAN_ARRAY); - } - }).name("booleanArray").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.DATE_ARRAY); - } - }).name("dateArray").build()); - } - }).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - - // then - assertResultTrue(createStatus); - assertClassesSize(1, schemaAfterCreate); - - WeaviateClass resultArraysClass = schemaAfterCreate.getResult().getClasses().get(0); - assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArraysClass); - assertPropertiesSize(6, resultArraysClass); - assertPropertyEquals("stringArray", DataType.TEXT_ARRAY, "field", - resultArraysClass.getProperties().get(0)); - assertPropertyEquals("textArray", DataType.TEXT_ARRAY, "word", - resultArraysClass.getProperties().get(1)); - assertPropertyEquals("intArray", DataType.INT_ARRAY, null, - resultArraysClass.getProperties().get(2)); - assertPropertyEquals("numberArray", DataType.NUMBER_ARRAY, null, - resultArraysClass.getProperties().get(3)); - assertPropertyEquals("booleanArray", DataType.BOOLEAN_ARRAY, null, - resultArraysClass.getProperties().get(4)); - assertPropertyEquals("dateArray", DataType.DATE_ARRAY, null, - resultArraysClass.getProperties().get(5)); - - assertResultTrue(deleteStatus); - assertClassesSize(0, schemaAfterDelete); - } - - @Test - public void testSchemaCreateClassWithProperties() { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Article") - .description("A written text, for example a news article or blog post") - .properties(new ArrayList() { - { - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("Title of the article").name("title").build()); - add(Property.builder().dataType(new ArrayList() { - { - add(DataType.TEXT); - } - }).description("The content of the article").name("content").build()); - } - }).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result schemaAfterCreate = client.schema().getter().run(); - Result deleteStatus = client.schema().allDeleter().run(); - Result schemaAfterDelete = client.schema().getter().run(); - - // then - assertResultTrue(createStatus); - assertClassesSize(1, schemaAfterCreate); - - WeaviateClass resultArticleClass = schemaAfterCreate.getResult().getClasses().get(0); - assertClassEquals(clazz.getClassName(), clazz.getDescription(), resultArticleClass); - assertPropertiesSize(2, resultArticleClass); - assertPropertyEquals("title", "word", resultArticleClass.getProperties().get(0)); - assertPropertyEquals("content", "word", resultArticleClass.getProperties().get(1)); - - assertResultTrue(deleteStatus); - assertClassesSize(0, schemaAfterDelete); - } - - @Test - public void testSchemaCreateClassWithInvalidTokenizationProperty() { - // given - WeaviateClass pizza = WeaviateClass.builder().className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - - Property notExistingTokenization = Property.builder().dataType(Collections.singletonList(DataType.TEXT)) - .description("someString").name("someString").tokenization("not-existing").build(); - Property notSupportedTokenizationForInt = Property.builder().dataType(Collections.singletonList(DataType.INT)) - .description("someInt") - .name("someInt").tokenization(Tokenization.WORD).build(); - // when - Result createStatus = client.schema().classCreator().withClass(pizza).run(); - Result notExistingTokenizationCreateStatus = client.schema().propertyCreator() - .withProperty(notExistingTokenization).withClassName(pizza.getClassName()).run(); - Result notSupportedTokenizationForIntCreateStatus = client.schema().propertyCreator() - .withProperty(notSupportedTokenizationForInt).withClassName(pizza.getClassName()).run(); - - // then - assertResultTrue(createStatus); - - assertResultError( - "tokenization in body should be one of [word lowercase whitespace field trigram gse kagome_kr kagome_ja gse_ch]", - notExistingTokenizationCreateStatus); - assertResultError("tokenization is not allowed for data type 'int'", - notSupportedTokenizationForIntCreateStatus); - } - - @Test - public void testCreateClassWithBM25Config() { - // given - BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().bm25(bm25Config).build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertNotNull(bandClass.getResult().getInvertedIndexConfig().getBm25()); - assertEquals(bm25Config.getB(), - bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); - assertEquals(bm25Config.getK1(), - bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); - } - - @Test - public void testCreateClassWithInvertedIndexContainingIndexNullState() { - // given - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().indexNullState(true).build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertTrue(bandClass.getResult().getInvertedIndexConfig().getIndexNullState()); - } - - @Test - public void testCreateClassWithInvertedIndexContainingIndexPropertyLength() { - // given - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().indexPropertyLength(true).build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertTrue(bandClass.getResult().getInvertedIndexConfig().getIndexPropertyLength()); - } - - @Test - public void testCreateClassWithStopwordsConfig() { - // given - StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") - .additions(new String[] { "star", "nebula" }).removals(new String[] { "a", "the" }).build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().stopwords(stopwordConfig).build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertNotNull(bandClass.getResult().getInvertedIndexConfig().getStopwords()); - assertEquals(stopwordConfig.getPreset(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); - } - - @Test - public void testCreateClassWithBM25ConfigAndWithStopwordsConfig() { - // given - BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); - - StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") - .additions(new String[] { "star", "nebula" }).removals(new String[] { "a", "the" }).build(); - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().bm25(bm25Config).stopwords(stopwordConfig) - .build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertNotNull(bandClass.getResult().getInvertedIndexConfig().getBm25()); - assertEquals(bm25Config.getB(), - bandClass.getResult().getInvertedIndexConfig().getBm25().getB()); - assertEquals(bm25Config.getK1(), - bandClass.getResult().getInvertedIndexConfig().getBm25().getK1()); - assertNotNull(bandClass.getResult().getInvertedIndexConfig().getStopwords()); - assertEquals(stopwordConfig.getPreset(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), - bandClass.getResult().getInvertedIndexConfig().getStopwords().getRemovals()); - } - - @Test - public void testCreateClassWithInvertedIndexConfigAndVectorIndexConfigAndShardConfig() { - // given - BM25Config bm25Config = BM25Config.builder().b(0.777f).k1(1.777f).build(); - StopwordConfig stopwordConfig = StopwordConfig.builder().preset("en") - .additions(new String[] { "star", "nebula" }).removals(new String[] { "a", "the" }).build(); - Integer cleanupIntervalSeconds = 300; - // vector index config - Integer efConstruction = 128; - Integer maxConnections = 64; - Long vectorCacheMaxObjects = 500000L; - Integer ef = -1; - Boolean skip = false; - Integer dynamicEfFactor = 8; - Integer dynamicEfMax = 500; - Integer dynamicEfMin = 100; - Integer flatSearchCutoff = 40000; - String distance = DistanceType.DOT; - // pq config - Boolean enabled = true; - Boolean bitCompression = true; - Integer segments = 4; - Integer centroids = 8; - String encoderType = "tile"; - String encoderDistribution = "normal"; - // shard config - Integer actualCount = 1; - Integer actualVirtualCount = 128; - Integer desiredCount = 1; - Integer desiredVirtualCount = 128; - String function = "murmur3"; - String key = "_id"; - String strategy = "hash"; - Integer virtualPerPhysical = 128; - - InvertedIndexConfig invertedIndexConfig = InvertedIndexConfig.builder().bm25(bm25Config) - .stopwords(stopwordConfig).cleanupIntervalSeconds(cleanupIntervalSeconds).build(); - - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder().cleanupIntervalSeconds(cleanupIntervalSeconds) - .efConstruction(efConstruction).maxConnections(maxConnections) - .vectorCacheMaxObjects(vectorCacheMaxObjects).ef(ef).skip(skip) - .dynamicEfFactor(dynamicEfFactor).dynamicEfMax(dynamicEfMax).dynamicEfMin(dynamicEfMin) - .flatSearchCutoff(flatSearchCutoff).distance(distance).pq( - PQConfig.builder().enabled(enabled).bitCompression(bitCompression) - .segments(segments).centroids(centroids).encoder(PQConfig.Encoder.builder() - .type(encoderType).distribution(encoderDistribution).build()) - .build()) - .build(); - - ShardingConfig shardingConfig = ShardingConfig.builder().actualCount(actualCount) - .actualVirtualCount(actualVirtualCount) - .desiredCount(desiredCount).desiredVirtualCount(desiredVirtualCount).function(function) - .key(key).strategy(strategy).virtualPerPhysical(virtualPerPhysical).build(); - - WeaviateClass clazz = WeaviateClass.builder().className("Band") - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").invertedIndexConfig(invertedIndexConfig) - .vectorIndexConfig(vectorIndexConfig).shardingConfig(shardingConfig).build(); - - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - // then - assertNotNull(createStatus); - assertNull(createStatus.getError()); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - InvertedIndexConfig classInvertedIndexConfig = bandClass.getResult().getInvertedIndexConfig(); - assertNotNull(classInvertedIndexConfig.getBm25()); - assertEquals(bm25Config.getB(), classInvertedIndexConfig.getBm25().getB()); - assertEquals(bm25Config.getK1(), classInvertedIndexConfig.getBm25().getK1()); - assertNotNull(classInvertedIndexConfig.getStopwords()); - assertEquals(stopwordConfig.getPreset(), classInvertedIndexConfig.getStopwords().getPreset()); - assertArrayEquals(stopwordConfig.getAdditions(), - classInvertedIndexConfig.getStopwords().getAdditions()); - assertArrayEquals(stopwordConfig.getRemovals(), - classInvertedIndexConfig.getStopwords().getRemovals()); - assertEquals(cleanupIntervalSeconds, classInvertedIndexConfig.getCleanupIntervalSeconds()); - VectorIndexConfig classVectorIndexConfig = bandClass.getResult().getVectorIndexConfig(); - assertEquals(maxConnections, classVectorIndexConfig.getMaxConnections()); - assertEquals(efConstruction, classVectorIndexConfig.getEfConstruction()); - assertEquals(vectorCacheMaxObjects, classVectorIndexConfig.getVectorCacheMaxObjects()); - assertEquals(ef, classVectorIndexConfig.getEf()); - assertEquals(skip, classVectorIndexConfig.getSkip()); - assertEquals(dynamicEfFactor, classVectorIndexConfig.getDynamicEfFactor()); - assertEquals(dynamicEfMax, classVectorIndexConfig.getDynamicEfMax()); - assertEquals(dynamicEfMin, classVectorIndexConfig.getDynamicEfMin()); - assertEquals(flatSearchCutoff, classVectorIndexConfig.getFlatSearchCutoff()); - assertEquals(distance, classVectorIndexConfig.getDistance()); - - assertThat(classVectorIndexConfig.getPq()).isNotNull().returns(enabled, PQConfig::getEnabled) - .returns(bitCompression, PQConfig::getBitCompression) - .returns(segments, PQConfig::getSegments).returns(centroids, PQConfig::getCentroids); - assertThat(classVectorIndexConfig.getPq().getEncoder()).isNotNull() - .returns(encoderType, PQConfig.Encoder::getType) - .returns(encoderDistribution, PQConfig.Encoder::getDistribution); - - ShardingConfig classShardingIndexConfig = bandClass.getResult().getShardingConfig(); - assertEquals(actualCount, classShardingIndexConfig.getActualCount()); - assertEquals(actualVirtualCount, classShardingIndexConfig.getActualVirtualCount()); - assertEquals(desiredCount, classShardingIndexConfig.getDesiredCount()); - assertEquals(desiredVirtualCount, classShardingIndexConfig.getDesiredVirtualCount()); - assertEquals(function, classShardingIndexConfig.getFunction()); - assertEquals(key, classShardingIndexConfig.getKey()); - assertEquals(strategy, classShardingIndexConfig.getStrategy()); - assertEquals(virtualPerPhysical, classShardingIndexConfig.getVirtualPerPhysical()); - } - - @Test - public void testSchemaGetBandClass() { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Band").description("Band that plays and produces music") - .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - Result nonExistentClass = client.schema().classGetter().withClassName("nonExistentClass").run(); - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(bandClass); - assertNotNull(bandClass.getResult()); - assertNull(bandClass.getError()); - assertEquals(clazz.getClassName(), bandClass.getResult().getClassName()); - assertEquals(clazz.getDescription(), bandClass.getResult().getDescription()); - assertEquals(clazz.getVectorIndexType(), bandClass.getResult().getVectorIndexType()); - assertEquals(clazz.getVectorizer(), bandClass.getResult().getVectorizer()); - assertNotNull(nonExistentClass); - assertNull(nonExistentClass.getError()); - assertNull(nonExistentClass.getResult()); - } - - @Test - public void testSchemaGetShards() { - // given - WeaviateClass clazz = WeaviateClass.builder().className("Band").description("Band that plays and produces music") - .vectorIndexType("hnsw").vectorizer("text2vec-contextionary").build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - Result bandClassExists = client.schema().exists().withClassName(clazz.getClassName()).run(); - Result nonExistentClassExists = client.schema().exists().withClassName("nonExistentClass").run(); - // then - assertResultTrue(createStatus); - assertResultTrue(bandClassExists); - assertNotNull(nonExistentClassExists); - assertFalse(nonExistentClassExists.getResult()); - assertNull(nonExistentClassExists.getError()); - Result shards = client.schema().shardsGetter().withClassName(clazz.getClassName()).run(); - assertNotNull(shards); - assertNotNull(shards.getResult()); - assertEquals(1, shards.getResult().length); - Shard shard = shards.getResult()[0]; - assertNotNull(shard.getName()); - assertNotNull(shard.getStatus()); - } - - @Test - public void testSchemaUpdateShard() { - // given - String className = "Band"; - WeaviateClass clazz = WeaviateClass.builder().className(className) - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertNull(createStatus.getError()); - assertTrue(createStatus.getResult()); - // then - Result shards = client.schema().shardsGetter().withClassName(className).run(); - assertNotNull(shards); - assertNull(shards.getError()); - assertNotNull(shards.getResult()); - assertEquals(1, shards.getResult().length); - // check the shard status, should be READY - assertEquals(ShardStatuses.READY, shards.getResult()[0].getStatus()); - // get shard's name - String shardName = shards.getResult()[0].getName(); - assertNotNull(shardName); - // update shard status to READONLY - Result updateToREADONLY = client.schema().shardUpdater().withClassName(className) - .withShardName(shardName).withStatus(ShardStatuses.READONLY).run(); - assertNotNull(updateToREADONLY.getResult()); - assertEquals(ShardStatuses.READONLY, updateToREADONLY.getResult().getStatus()); - // update shard status to READY - Result updateToREADY = client.schema().shardUpdater().withClassName(className) - .withShardName(shardName).withStatus(ShardStatuses.READY).run(); - assertNotNull(updateToREADY.getResult()); - assertEquals(ShardStatuses.READY, updateToREADY.getResult().getStatus()); - } - - @Test - public void testSchemaUpdateShards() { - // given - String className = "Band"; - int shardCount = 3; - ShardingConfig shardingConfig = ShardingConfig.builder().actualCount(shardCount) - .actualVirtualCount(128).desiredCount(shardCount).desiredVirtualCount(128) - .function("murmur3").key("_id").strategy("hash").virtualPerPhysical(128).build(); - WeaviateClass clazz = WeaviateClass.builder().className(className) - .description("Band that plays and produces music").vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary").shardingConfig(shardingConfig).build(); - // when - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - assertResultTrue(createStatus); - // then - Result shards = client.schema().shardsGetter().withClassName(className).run(); - assertNotNull(shards); - assertNull(shards.getError()); - assertNotNull(shards.getResult()); - assertEquals(3, shards.getResult().length); - // update shard status to READONLY - Result updateToREADONLY = client.schema().shardsUpdater() - .withClassName(className).withStatus(ShardStatuses.READONLY).run(); - assertNotNull(updateToREADONLY.getResult()); - assertEquals(3, updateToREADONLY.getResult().length); - for (ShardStatus s : updateToREADONLY.getResult()) { - assertEquals(ShardStatuses.READONLY, s.getStatus()); - } - // update shard status to READY - Result updateToREADY = client.schema().shardsUpdater().withClassName(className) - .withStatus(ShardStatuses.READY).run(); - assertNotNull(updateToREADY.getResult()); - assertEquals(3, updateToREADY.getResult().length); - for (ShardStatus s : updateToREADY.getResult()) { - assertEquals(ShardStatuses.READY, s.getStatus()); - } - } - - @Test - public void testSchemaUpdateShardsException() { - // when - Result res = client.schema().shardsUpdater().run(); - Result res2 = client.schema().shardsUpdater().withStatus(ShardStatuses.READY).run(); - Result res3 = client.schema().shardsUpdater().withClassName("class").run(); - // then - assertResultError("className, status cannot be empty", res); - assertResultError("className cannot be empty", res2); - assertResultError("status cannot be empty", res3); - } - - @Test - public void testSchemaUpdateShardException() { - // when - Result res = client.schema().shardUpdater().run(); - Result res2 = client.schema().shardUpdater().withStatus(ShardStatuses.READY).run(); - Result res3 = client.schema().shardUpdater().withClassName("class").run(); - Result res4 = client.schema().shardUpdater().withShardName("shardName").run(); - // then - assertResultError("className, shardName, status cannot be empty", res); - assertResultError("className, shardName cannot be empty", res2); - assertResultError("shardName, status cannot be empty", res3); - assertResultError("className, status cannot be empty", res4); - } - - @Test - public void testSchemaGetShardsException() { - // when - Result res = client.schema().shardsGetter().run(); - // then - assertResultError("className cannot be empty", res); - } - - private void assertResultTrue(Result result) { - assertNotNull(result); - assertTrue(result.getResult()); - } - - private void assertResultError(String msg, Result result) { - assertNotNull(result); - assertTrue(result.hasErrors()); - List messages = result.getError().getMessages(); - assertEquals(1, messages.size()); - assertEquals(msg, messages.get(0).getMessage()); - } - - private void assertClassesSize(int expectedSize, Result schemaAfterCreate) { - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(expectedSize, schemaAfterCreate.getResult().getClasses().size()); - } - - private void assertClassEquals(String expectedName, String expectedDescription, - WeaviateClass schemaClass) { - assertEquals(expectedName, schemaClass.getClassName()); - assertEquals(expectedDescription, schemaClass.getDescription()); - } - - private void assertPropertiesSize(int expectedSize, WeaviateClass schemaClass) { - assertNotNull(schemaClass.getProperties()); - assertEquals(expectedSize, schemaClass.getProperties().size()); - } - - private void assertPropertyEquals(String expectedName, String expectedTokenization, - Property property) { - assertEquals(expectedName, property.getName()); - assertEquals(expectedTokenization, property.getTokenization()); - } - - private void assertPropertyEquals(String expectedName, String expectedDataType, - String expectedTokenization, Property property) { - assertPropertyEquals(expectedName, expectedTokenization, property); - assertTrue(property.getDataType().size() > 0); - assertEquals(expectedDataType, property.getDataType().get(0)); - } - - @Test - public void shouldAddObjectsWithNestedProperties_EntireSchema() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding object 1 - WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), object1); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding object 2 - WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), object2); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_PartialSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema did not change after adding object 1 - WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), object1); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 2 - WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), object2); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_PartialSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema did not change after adding object 2 - WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), object2); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 1 - WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), object1); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_NoSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - // schema created after adding object 1 - WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), object1); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 2 - WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), object2); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_NoSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - // schema created after adding object 2 - WeaviateObject object2 = utils.createObject(client, utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), object2); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 1 - WeaviateObject object1 = utils.createObject(client, utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), object1); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_EntireSchema() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), - utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_PartialSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), - utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_PartialSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - Map expectedPropsStep2 = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); - utils.createClass(client, wvtClass); - - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), - utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_NoSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - // schema created after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject1(className), - utils.nestedObject2(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[0]); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[1]); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_NoSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() { - { - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - } - }; - - // schema created after adding objects - ObjectGetResponse[] objects = utils.batchObjects(client, utils.nestedObject2(className), - utils.nestedObject1(className)); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject2(className), objects[0]); - utils.assertThatObjectsAreSimilar(utils.expectedNestedObject1(className), objects[1]); - schemaClass = utils.getClass(client, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_FromFileNestedObject() throws Exception { - // given - File jsonFile = new File("src/test/resources/json/nested-one-object.json"); - InputStreamReader reader = new InputStreamReader(Files.newInputStream(jsonFile.toPath())); - // when - Object nestedOneObject = new Gson().fromJson(reader, Object.class); - String className = "ClassWithOneObjectPropertyFromFile"; - String id = "d3ca0fc9-d392-4253-8f2a-0bce51efff80"; - - Map props = new HashMap<>(); - props.put("name", "nested object from file"); - props.put("objectProperty", nestedOneObject); - - WeaviateObject weaviateObject = WeaviateObject.builder().className(className).id(id).properties(props).build(); - - // then - ObjectGetResponse[] objects = utils.batchObjects(client, weaviateObject); - assertThat(objects).isNotEmpty(); - Result> result = client.data().objectsGetter().withID(id).withClassName(className).run(); - assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .isNotNull().extracting(objs -> objs.get(0)).isNotNull().satisfies(obj -> { - assertThat(obj.getId()).isEqualTo(id); - assertThat(obj.getProperties()).isNotNull().extracting(p -> p.get("objectProperty")) - .isNotNull(); - }); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_FromFileNestedArrayObject() throws Exception { - // given - File jsonFile = new File("src/test/resources/json/nested-array-object.json"); - InputStreamReader reader = new InputStreamReader(Files.newInputStream(jsonFile.toPath())); - // when - Object nestedArrayObject = new Gson().fromJson(reader, Object.class); - String className = "ClassWithOneObjectArrayPropertyFromFile"; - String id = "d3ca0fc9-d392-4253-8f2a-0bce51efff80"; - - Map props = new HashMap<>(); - props.put("name", "nested object from file"); - props.put("objectArrayProperty", nestedArrayObject); - - WeaviateObject weaviateObject = WeaviateObject.builder().className(className).id(id).properties(props).build(); - - // then - ObjectGetResponse[] objects = utils.batchObjects(client, weaviateObject); - assertThat(objects).isNotEmpty(); - Result> result = client.data().objectsGetter().withID(id).withClassName(className).run(); - assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .isNotNull().extracting(objs -> objs.get(0)).isNotNull().satisfies(obj -> { - assertThat(obj.getId()).isEqualTo(id); - assertThat(obj.getProperties()).isNotNull().extracting(p -> p.get("objectArrayProperty")) - .isNotNull(); - }); - } - - @Test - public void shouldUpdateClass() { - String className = "Question"; - List properties = Arrays.asList( - Property.builder().name("question").dataType(Arrays.asList(DataType.TEXT)).build(), - Property.builder().name("answer").dataType(Arrays.asList(DataType.TEXT)).build()); - - WeaviateClass jeopardyClass = WeaviateClass.builder().className(className).description("A Jeopardy! question") - .vectorizer("text2vec-contextionary").properties(properties).build(); - - Result createResult = client.schema().classCreator().withClass(jeopardyClass).run(); - - assertThat(createResult).isNotNull().withFailMessage(() -> createResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); - - Result createdClassResult = client.schema().classGetter().withClassName(className).run(); - - assertThat(createdClassResult).isNotNull() - .withFailMessage(() -> createdClassResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) - .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .extracting(VectorIndexConfig::getPq).isNotNull().returns(false, PQConfig::getEnabled); - - WeaviateClass newJeopardyClass = WeaviateClass.builder().className(className) - .vectorizer("text2vec-contextionary").properties(properties) - .vectorIndexConfig( - VectorIndexConfig.builder().filterStrategy(VectorIndexConfig.FilterStrategy.ACORN) - .pq(PQConfig.builder().enabled(true).trainingLimit(99_999).segments(96).build()) - .build()) - .replicationConfig(ReplicationConfig.builder() - .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT).build()) - .build(); - - Result updateResult = client.schema().classUpdater().withClass(newJeopardyClass).run(); - - assertThat(updateResult).isNotNull().withFailMessage(() -> updateResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).returns(true, Result::getResult); - - Result updatedClassResult = client.schema().classGetter().withClassName(className).run(); - - assertThat(updatedClassResult).isNotNull() - .withFailMessage(() -> updatedClassResult.getError().toString()) - .returns(false, Result::hasErrors).withFailMessage(null).extracting(Result::getResult) - .isNotNull().extracting(WeaviateClass::getVectorIndexConfig).isNotNull() - .returns(VectorIndexConfig.FilterStrategy.ACORN, VectorIndexConfig::getFilterStrategy) - .extracting(VectorIndexConfig::getPq).isNotNull().returns(true, PQConfig::getEnabled) - .returns(96, PQConfig::getSegments).returns(99_999, PQConfig::getTrainingLimit); - - assertThat(updatedClassResult.getResult()).extracting(WeaviateClass::getReplicationConfig) - .isNotNull().returns(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT, - ReplicationConfig::getDeletionStrategy); - } - - @Test - public void shouldCreateClassWithVectorAndReplicationConfig() { - Integer cleanupIntervalSeconds = 300; - // vector index config - Integer efConstruction = 128; - Integer maxConnections = 64; - Long vectorCacheMaxObjects = 500000L; - Integer ef = -1; - Boolean skip = false; - Integer dynamicEfFactor = 8; - Integer dynamicEfMax = 500; - Integer dynamicEfMin = 100; - Integer flatSearchCutoff = 40000; - String distance = DistanceType.DOT; - // pq config - Boolean enabled = true; - Boolean bitCompression = true; - Integer segments = 4; - Integer centroids = 8; - String encoderType = "tile"; - String encoderDistribution = "normal"; - // replication config - Boolean asyncEnabled = true; - Integer replicationFactor = 1; - - VectorIndexConfig vectorIndexConfig = VectorIndexConfig.builder().cleanupIntervalSeconds(cleanupIntervalSeconds) - .efConstruction(efConstruction).maxConnections(maxConnections) - .vectorCacheMaxObjects(vectorCacheMaxObjects).ef(ef).skip(skip) - .filterStrategy(VectorIndexConfig.FilterStrategy.SWEEPING) - .dynamicEfFactor(dynamicEfFactor).dynamicEfMax(dynamicEfMax).dynamicEfMin(dynamicEfMin) - .flatSearchCutoff(flatSearchCutoff).distance(distance).pq( - PQConfig.builder().enabled(enabled).bitCompression(bitCompression) - .segments(segments).centroids(centroids).encoder(PQConfig.Encoder.builder() - .type(encoderType).distribution(encoderDistribution).build()) - .build()) - .build(); - - ReplicationConfig replicationConfig = ReplicationConfig.builder().factor(replicationFactor) - .asyncEnabled(asyncEnabled) - .deletionStrategy(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION).build(); - - Map contextionaryVectorizerSettings = new HashMap<>(); - contextionaryVectorizerSettings.put("vectorizeClassName", true); - Map contextionaryVectorizer = new HashMap<>(); - contextionaryVectorizer.put("text2vec-contextionary", contextionaryVectorizerSettings); - - Map vectorConfig = new HashMap<>(); - vectorConfig.put("hnswVector", - WeaviateClass.VectorConfig.builder().vectorIndexConfig(vectorIndexConfig) - .vectorIndexType("hnsw").vectorizer(contextionaryVectorizer).build()); - - WeaviateClass clazz = WeaviateClass.builder().className("Band").description("Band that plays and produces music") - .vectorConfig(vectorConfig).replicationConfig(replicationConfig).build(); - - Result createStatus = client.schema().classCreator().withClass(clazz).run(); - - assertThat(createStatus).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - - Result bandClass = client.schema().classGetter().withClassName(clazz.getClassName()).run(); - - assertThat(bandClass).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull().extracting(WeaviateClass::getVectorConfig) - .satisfies(vc -> assertThat(vc).isNotNull().containsOnlyKeys("hnswVector") - .extracting(vcMap -> vcMap.get("hnswVector")).isNotNull() - .satisfies(hnswVectorConfig -> { - assertThat(hnswVectorConfig) - .extracting(WeaviateClass.VectorConfig::getVectorIndexType).isEqualTo("hnsw"); - - assertThat(hnswVectorConfig).extracting(WeaviateClass.VectorConfig::getVectorizer) - .satisfies(vectorizer -> assertThat(vectorizer).isNotNull() - .containsOnlyKeys("text2vec-contextionary") - .extracting(vectorizerMap -> vectorizerMap.get("text2vec-contextionary")) - .isNotNull()); - - assertThat(hnswVectorConfig) - .extracting(WeaviateClass.VectorConfig::getVectorIndexConfig) - .returns(cleanupIntervalSeconds, VectorIndexConfig::getCleanupIntervalSeconds) - .returns(efConstruction, VectorIndexConfig::getEfConstruction) - .returns(maxConnections, VectorIndexConfig::getMaxConnections) - .returns(VectorIndexConfig.FilterStrategy.SWEEPING, - VectorIndexConfig::getFilterStrategy) - .returns(vectorCacheMaxObjects, VectorIndexConfig::getVectorCacheMaxObjects) - .returns(ef, VectorIndexConfig::getEf).returns(skip, VectorIndexConfig::getSkip) - .returns(dynamicEfFactor, VectorIndexConfig::getDynamicEfFactor) - .returns(dynamicEfMax, VectorIndexConfig::getDynamicEfMax) - .returns(dynamicEfMin, VectorIndexConfig::getDynamicEfMin) - .returns(flatSearchCutoff, VectorIndexConfig::getFlatSearchCutoff) - .returns(distance, VectorIndexConfig::getDistance) - - .extracting(VectorIndexConfig::getPq).isNotNull() - .returns(enabled, PQConfig::getEnabled) - .returns(bitCompression, PQConfig::getBitCompression) - .returns(segments, PQConfig::getSegments) - .returns(centroids, PQConfig::getCentroids) - - .extracting(PQConfig::getEncoder).returns(encoderType, PQConfig.Encoder::getType) - .returns(encoderDistribution, PQConfig.Encoder::getDistribution); - })); - - assertThat(bandClass.getResult()).extracting(WeaviateClass::getReplicationConfig).isNotNull() - .returns(replicationFactor, ReplicationConfig::getFactor) - .returns(asyncEnabled, ReplicationConfig::getAsyncEnabled) - .returns(ReplicationConfig.DeletionStrategy.NO_AUTOMATED_RESOLUTION, - ReplicationConfig::getDeletionStrategy); - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/ClusterSchemaTest.java b/src/test/java/io/weaviate/integration/client/schema/ClusterSchemaTest.java deleted file mode 100644 index a96a7d87c..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/ClusterSchemaTest.java +++ /dev/null @@ -1,496 +0,0 @@ -package io.weaviate.integration.client.schema; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.misc.model.ReplicationConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateDockerComposeCluster; -import java.util.HashMap; -import java.util.Map; -import org.apache.http.HttpStatus; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.STRING; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; - - -public class ClusterSchemaTest { - private WeaviateClient client1; - private WeaviateClient client2; - private final NestedObjectsUtils utils = new NestedObjectsUtils(); - - @ClassRule - public static WeaviateDockerComposeCluster compose = new WeaviateDockerComposeCluster(); - - @Before - public void before() { - Config config1 = new Config("http", compose.getHttpHost0Address()); - client1 = new WeaviateClient(config1); - - Config config2 = new Config("http", compose.getHttpHost1Address()); - client2 = new WeaviateClient(config2); - } - - @After - public void after() { - Result deleted = client1.schema().allDeleter().run(); - assertThat(deleted.hasErrors()).isFalse(); - } - - @Test - public void shouldCreateClassWithImplicitReplicationFactor() { - assertClassReplicationSettings(1, null); - } - - @Test - public void shouldCreateClassWithExplicitReplicationFactor() { - assertClassReplicationSettings(2, null); - } - - @Test - public void shouldCreateClassWithExplicitAsyncReplicationWithImplicitReplicationFactor() { - assertClassReplicationSettings(1, false); - } - - @Test - public void shouldCreateClassWithExplicitAsyncReplicationAndExplicitReplicationFactor() { - assertClassReplicationSettings(2, true); - } - - @Test - public void shouldNotCreateClassWithTooHighFactor() { - // given - int replicationFactor = 3; - - String className = "Band"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .replicationConfig(ReplicationConfig.builder().factor(replicationFactor).build()) - .build(); - - // when - Result createStatus = client1.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus).isNotNull() - .returns(true, Result::hasErrors) - .extracting(Result::getError) - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .first() - .extracting(m -> ((WeaviateErrorMessage) m).getMessage()).asInstanceOf(STRING) - .contains("could not find enough weaviate nodes for replication"); - } - - @Test - public void shouldAddObjectsWithNestedProperties_EntireSchema() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding object 1 - utils.createObject(client1, utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding object 2 - utils.createObject(client1, utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_PartialSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema did not change after adding object 1 - utils.createObject(client1, utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 2 - utils.createObject(client1, utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_PartialSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema did not change after adding object 2 - utils.createObject(client1, utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 1 - utils.createObject(client1, utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_NoSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - // schema created after adding object 1 - utils.createObject(client1, utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 2 - utils.createObject(client1, utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldAddObjectsWithNestedProperties_NoSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - // schema created after adding object 2 - utils.createObject(client1, utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding object 1 - utils.createObject(client1, utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_EntireSchema() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassEntireSchema(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - - // schema did not change after adding objects - utils.batchObjects(client1, utils.nestedObject1(className), utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_PartialSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.INT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema1(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding objects - utils.batchObjects(client1, utils.nestedObject1(className), utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_PartialSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedPropsStep1 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - Map expectedPropsStep2 = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - WeaviateClass wvtClass = utils.nestedClassPartialSchema2(className); - utils.createClass(client1, wvtClass); - - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep1, schemaClass); - - // schema changed after adding objects - utils.batchObjects(client1, utils.nestedObject1(className), utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedPropsStep2, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_NoSchema1() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - // schema created after adding objects - utils.batchObjects(client1, utils.nestedObject1(className), utils.nestedObject2(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - @Test - public void shouldBatchObjectsWithNestedProperties_NoSchema2() { - WeaviateClass schemaClass; - String className = "ClassWithObjectProperty"; - Map expectedProps = new HashMap() {{ - put("name", DataType.TEXT); - put("objectProperty", DataType.OBJECT); - put("objectProperty.nestedInt", DataType.NUMBER); // autoschema determines type as number - put("objectProperty.nestedNumber", DataType.NUMBER); - put("objectProperty.nestedText", DataType.TEXT); - put("objectProperty.nestedObjects", DataType.OBJECT_ARRAY); - put("objectProperty.nestedObjects.nestedBoolLvl2", DataType.BOOLEAN); - put("objectProperty.nestedObjects.nestedDateLvl2", DataType.DATE); - put("objectProperty.nestedObjects.nestedNumbersLvl2", DataType.NUMBER_ARRAY); - }}; - - // schema created after adding objects - utils.batchObjects(client1, utils.nestedObject2(className), utils.nestedObject1(className)); - schemaClass = utils.getClass(client1, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - schemaClass = utils.getClass(client2, className); - utils.assertThatSchemaPropertiesHaveDataTypes(expectedProps, schemaClass); - } - - private void assertClassReplicationSettings(int replicationFactor, Boolean asyncEnabled) { - // given - ReplicationConfig.ReplicationConfigBuilder replicationConfigBuilder = ReplicationConfig.builder().factor(replicationFactor); - if (asyncEnabled != null) { - replicationConfigBuilder = replicationConfigBuilder.asyncEnabled(asyncEnabled); - } - String className = "Band"; - WeaviateClass clazz = WeaviateClass.builder() - .className(className) - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .replicationConfig(replicationConfigBuilder.build()) - .build(); - - // when - Result createStatus = client1.schema().classCreator().withClass(clazz).run(); - assertThat(createStatus).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // then - Result classResult = client1.schema().classGetter().withClassName(className).run(); - assertThat(classResult).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(WeaviateClass::getReplicationConfig) - .isNotNull() - .satisfies(rc -> { - assertThat(rc.getFactor()).isEqualTo(replicationFactor); - if (asyncEnabled != null) { - assertThat(rc.getAsyncEnabled()).isEqualTo(asyncEnabled); - } else { - assertThat(rc.getAsyncEnabled()).isEqualTo(false); - } - }); - } -} diff --git a/src/test/java/io/weaviate/integration/client/schema/NestedObjectsUtils.java b/src/test/java/io/weaviate/integration/client/schema/NestedObjectsUtils.java deleted file mode 100644 index 448c27c00..000000000 --- a/src/test/java/io/weaviate/integration/client/schema/NestedObjectsUtils.java +++ /dev/null @@ -1,363 +0,0 @@ -package io.weaviate.integration.client.schema; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import org.apache.commons.lang3.StringUtils; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.stream.Collectors; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -class NestedObjectsUtils { - - WeaviateClass nestedClassEntireSchema(String className) { - return WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.builder() - .name("objectProperty") - .dataType(Arrays.asList(DataType.OBJECT)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedInt") - .dataType(Arrays.asList(DataType.INT)) - .build(), - Property.NestedProperty.builder() - .name("nestedNumber") - .dataType(Arrays.asList(DataType.NUMBER)) - .build(), - Property.NestedProperty.builder() - .name("nestedText") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.NestedProperty.builder() - .name("nestedObjects") - .dataType(Arrays.asList(DataType.OBJECT_ARRAY)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedBoolLvl2") - .dataType(Arrays.asList(DataType.BOOLEAN)) - .build(), - Property.NestedProperty.builder() - .name("nestedDateLvl2") - .dataType(Arrays.asList(DataType.DATE)) - .build(), - Property.NestedProperty.builder() - .name("nestedNumbersLvl2") - .dataType(Arrays.asList(DataType.NUMBER_ARRAY)) - .build() - )) - .build() - )) - .build() - )) - .build(); - } - - WeaviateClass nestedClassPartialSchema1(String className) { - return WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.builder() - .name("objectProperty") - .dataType(Arrays.asList(DataType.OBJECT)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedInt") - .dataType(Arrays.asList(DataType.INT)) - .build(), - Property.NestedProperty.builder() - .name("nestedText") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.NestedProperty.builder() - .name("nestedObjects") - .dataType(Arrays.asList(DataType.OBJECT_ARRAY)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedBoolLvl2") - .dataType(Arrays.asList(DataType.BOOLEAN)) - .build(), - Property.NestedProperty.builder() - .name("nestedNumbersLvl2") - .dataType(Arrays.asList(DataType.NUMBER_ARRAY)) - .build() - )) - .build() - )) - .build() - )) - .build(); - } - - WeaviateClass nestedClassPartialSchema2(String className) { - return WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.builder() - .name("objectProperty") - .dataType(Arrays.asList(DataType.OBJECT)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedNumber") - .dataType(Arrays.asList(DataType.NUMBER)) - .build(), - Property.NestedProperty.builder() - .name("nestedText") - .dataType(Arrays.asList(DataType.TEXT)) - .build(), - Property.NestedProperty.builder() - .name("nestedObjects") - .dataType(Arrays.asList(DataType.OBJECT_ARRAY)) - .nestedProperties(Arrays.asList( - Property.NestedProperty.builder() - .name("nestedDateLvl2") - .dataType(Arrays.asList(DataType.DATE)) - .build(), - Property.NestedProperty.builder() - .name("nestedNumbersLvl2") - .dataType(Arrays.asList(DataType.NUMBER_ARRAY)) - .build() - )) - .build() - )) - .build() - )) - .build(); - } - - WeaviateObject nestedObject1(String className) { - Map nestedPropsLvl2 = new HashMap<>(); - nestedPropsLvl2.put("nestedBoolLvl2", false); - nestedPropsLvl2.put("nestedNumbersLvl2", Arrays.asList(1.1, 11.11)); - - Map nestedPropsLvl1 = new HashMap<>(); - nestedPropsLvl1.put("nestedInt", 111); - nestedPropsLvl1.put("nestedText", "some text 1"); - nestedPropsLvl1.put("nestedObjects", Arrays.asList(nestedPropsLvl2)); - - Map props = new HashMap<>(); - props.put("name", "object1"); - props.put("objectProperty", nestedPropsLvl1); - - return WeaviateObject.builder() - .className(className) - .id("040f2b60-b1e8-4b4d-ba0d-14cedb5144ab") - .properties(props) - .build(); - } - - WeaviateObject expectedNestedObject1(String className) { - // overwrite ints with doubles, as they are unmarshalled as that type - WeaviateObject o = nestedObject1(className); - Map objectProperty = (Map) o.getProperties().get("objectProperty"); - objectProperty.put("nestedInt", 111.0); - - return o; - } - - WeaviateObject nestedObject2(String className) { - Map nestedPropsLvl2 = new HashMap<>(); - nestedPropsLvl2.put("nestedDateLvl2", "2022-01-01T00:00:00+02:00"); - nestedPropsLvl2.put("nestedNumbersLvl2", Arrays.asList(2.2, 22.22)); - - Map nestedPropsLvl1 = new HashMap<>(); - nestedPropsLvl1.put("nestedNumber", 222); - nestedPropsLvl1.put("nestedText", "some text 2"); - nestedPropsLvl1.put("nestedObjects", Arrays.asList(nestedPropsLvl2)); - - Map props = new HashMap<>(); - props.put("name", "object2"); - props.put("objectProperty", nestedPropsLvl1); - - return WeaviateObject.builder() - .className(className) - .id("d3ca0fc9-d392-4253-8f2a-0bce51efff80") - .properties(props) - .build(); - } - - WeaviateObject expectedNestedObject2(String className) { - // overwrite ints with doubles, as they are unmarshalled as that type - WeaviateObject o = nestedObject2(className); - Map objectProperty = (Map) o.getProperties().get("objectProperty"); - objectProperty.put("nestedNumber", 222.0); - - return o; - } - - void createClass(WeaviateClient client, WeaviateClass wvtClass) { - Result createClass = client.schema().classCreator() - .withClass(wvtClass) - .run(); - - assertThat(createClass).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - WeaviateClass getClass(WeaviateClient client, String className) { - Result getSchema = client.schema().getter().run(); - assertThat(getSchema).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - Optional optionalClass = getSchema.getResult().getClasses().stream() - .filter(c -> className.equals(c.getClassName())) - .findFirst(); - assertThat(optionalClass).isPresent(); - - return optionalClass.get(); - } - - WeaviateObject createObject(WeaviateClient client, WeaviateObject object) { - Result createObject = client.data().creator() - .withID(object.getId()) - .withClassName(object.getClassName()) - .withProperties(object.getProperties()) - .run(); - - assertThat(createObject).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - return createObject.getResult(); - } - - ObjectGetResponse[] batchObjects(WeaviateClient client, WeaviateObject... objects) { - Result batchObjects = client.batch().objectsBatcher() - .withObjects(objects) - .run(); - - assertThat(batchObjects).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(objects.length); - - Arrays.stream(batchObjects.getResult()).forEach(obj -> { - assertThat(obj).isNotNull() - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - }); - - return batchObjects.getResult(); - } - - void assertThatSchemaPropertiesHaveDataTypes(Map expectedProps, WeaviateClass schemaClass) { - Map>> propNumbers = expectedProps.entrySet().stream().collect(Collectors.groupingBy(entry -> { - String[] parts = StringUtils.split(entry.getKey(), "."); - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < parts.length - 1; i++) { - if (i != 0) { - sb.append("."); - } - sb.append(parts[i]); - } - return sb.toString(); - })); - - propNumbers.forEach((propName, props) -> { - if ("".equals(propName)) { - assertThat(schemaClass.getProperties()).isNotNull() - .hasSize(props.size()); - } else { - String[] parts = StringUtils.split(propName, "."); - Optional optionalProp = schemaClass.getProperties().stream() - .filter(p -> parts[0].equals(p.getName())) - .findFirst(); - assertThat(optionalProp).isPresent(); - - List nestedProps = optionalProp.get().getNestedProperties(); - - for (int i = 1; i < parts.length; i++) { - int index = i; - Optional optionalNestedProp = nestedProps.stream() - .filter(np -> parts[index].equals(np.getName())) - .findFirst(); - assertThat(optionalNestedProp).isPresent(); - nestedProps = optionalNestedProp.get().getNestedProperties(); - } - - assertThat(nestedProps).hasSize(props.size()); - } - }); - - expectedProps.forEach((name, dataType) -> { - String[] parts = StringUtils.split(name, "."); - if (parts.length > 0) { - Optional optionalProp = schemaClass.getProperties().stream() - .filter(p -> parts[0].equals(p.getName())) - .findFirst(); - - assertThat(optionalProp).isPresent(); - Property property = optionalProp.get(); - - if (parts.length == 1) { - assertThat(property) - .extracting(Property::getDataType).asList() - .first().isEqualTo(dataType); - } else { - Property.NestedProperty nestedProp = null; - - List nestedProps = property.getNestedProperties(); - for (int i = 1; i < parts.length; i++) { - int index = i; - assertThat(nestedProps).isNotNull(); - Optional optionalNestedProp = nestedProps.stream() - .filter(np -> parts[index].equals(np.getName())) - .findFirst(); - assertThat(optionalNestedProp).isPresent(); - nestedProp = optionalNestedProp.get(); - nestedProps = nestedProp.getNestedProperties(); - } - - assertThat(nestedProp).isNotNull() - .extracting(Property.NestedProperty::getDataType).asList() - .first().isEqualTo(dataType); - } - } - }); - } - - void assertThatObjectsAreSimilar(WeaviateObject expectedObject, WeaviateObject object) { - assertThat(object).isNotNull() - .returns(expectedObject.getId(), WeaviateObject::getId) - .returns(expectedObject.getClassName(), WeaviateObject::getClassName) - .extracting(WeaviateObject::getProperties) - .isEqualTo(expectedObject.getProperties()); - } - void assertThatObjectsAreSimilar(WeaviateObject expectedObject, ObjectGetResponse object) { - assertThat(object).isNotNull() - .returns(expectedObject.getId(), ObjectGetResponse::getId) - .returns(expectedObject.getClassName(), ObjectGetResponse::getClassName) - .extracting(ObjectGetResponse::getProperties) - .isEqualTo(expectedObject.getProperties()); - } -} diff --git a/src/test/java/io/weaviate/integration/client/users/ClientUsersTest.java b/src/test/java/io/weaviate/integration/client/users/ClientUsersTest.java deleted file mode 100644 index 0223d97fd..000000000 --- a/src/test/java/io/weaviate/integration/client/users/ClientUsersTest.java +++ /dev/null @@ -1,133 +0,0 @@ -package io.weaviate.integration.client.users; - -import java.util.List; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.auth.exception.AuthException; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.users.DbUsers; -import io.weaviate.client.v1.users.OidcUsers; -import io.weaviate.client.v1.users.Users; -import io.weaviate.client.v1.users.model.User; -import io.weaviate.client.v1.users.model.UserDb; -import io.weaviate.integration.client.rbac.ClientRbacTest; -import io.weaviate.integration.tests.users.ClientUsersTestSuite; - -public class ClientUsersTest extends ClientRbacTest implements ClientUsersTestSuite.Users { - private final Users users; - - public ClientUsersTest(Config config, String apiKey) { - super(config, apiKey); - try { - this.users = WeaviateAuthClient.apiKey(config, apiKey).users(); - } catch (AuthException e) { - throw new RuntimeException(e); - } - } - - @Override - public Result getMyUser() { - return users.myUserGetter().run(); - } - - @Override - public Result> getUserRoles(String user) { - return users.userRolesGetter().withUserId(user).run(); - } - - @Override - public Result assignRoles(String user, String... roles) { - return this.users.assigner().withUserId(user).witRoles(roles).run(); - } - - @Override - public Result revokeRoles(String user, String... roles) { - return this.users.revoker().withUserId(user).witRoles(roles).run(); - } - - @Override - public ClientUsersTestSuite.DbUsers db() { - return new NamespacedUsers(false); - } - - @Override - public io.weaviate.integration.tests.users.ClientUsersTestSuite.OidcUsers oidc() { - return new NamespacedUsers(true); - } - - /** - * NamespacedUsers uses one of the namespaced clients based on the - * value of useOidc. This reduces code duplication, allowing us to - * reuse the same implementation for several test iterfaces. - */ - private class NamespacedUsers implements - ClientUsersTestSuite.DbUsers, ClientUsersTestSuite.OidcUsers { - private final DbUsers db; - private final OidcUsers oidc; - private final boolean useOidc; - - public NamespacedUsers(boolean useOidc) { - this.db = users.db(); - this.oidc = users.oidc(); - this.useOidc = useOidc; - } - - @Override - public Result assignRoles(String user, String... roles) { - return useOidc - ? oidc.assigner().withUserId(user).witRoles(roles).run() - : db.assigner().withUserId(user).witRoles(roles).run(); - } - - @Override - public Result revokeRoles(String user, String... roles) { - return useOidc - ? oidc.revoker().withUserId(user).witRoles(roles).run() - : db.revoker().withUserId(user).witRoles(roles).run(); - } - - @Override - public Result> getAssignedRoles(String user, boolean includePermissions) { - return useOidc - ? oidc.userRolesGetter().withUserId(user).includePermissions(includePermissions).run() - : db.userRolesGetter().withUserId(user).includePermissions(includePermissions).run(); - } - - @Override - public Result create(String user) { - return db.creator().withUserId(user).run(); - } - - @Override - public Result rotateKey(String user) { - return db.keyRotator().withUserId(user).run(); - } - - @Override - public Result delete(String user) { - return db.deleter().withUserId(user).run(); - } - - @Override - public Result activate(String user) { - return db.activator().withUserId(user).run(); - } - - @Override - public Result deactivate(String user, boolean revokeKey) { - return db.deactivator().withUserId(user).run(); - } - - @Override - public Result getUser(String user) { - return db.getUser().withUserId(user).run(); - } - - @Override - public Result> getAll() { - return db.allGetter().run(); - } - } -} diff --git a/src/test/java/io/weaviate/integration/tests/backup/BackupTestSuite.java b/src/test/java/io/weaviate/integration/tests/backup/BackupTestSuite.java deleted file mode 100644 index 2b339ddf2..000000000 --- a/src/test/java/io/weaviate/integration/tests/backup/BackupTestSuite.java +++ /dev/null @@ -1,731 +0,0 @@ -package io.weaviate.integration.tests.backup; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.fail; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import static org.assertj.core.api.InstanceOfAssertFactories.CHAR_SEQUENCE; -import static org.junit.Assume.assumeTrue; - -import java.nio.file.Paths; -import java.util.List; -import java.util.Map; -import java.util.concurrent.Callable; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; -import java.util.function.Supplier; - -import org.apache.http.HttpStatus; -import org.assertj.core.api.InstanceOfAssertFactories; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.aliases.model.Alias; -import io.weaviate.client.v1.backup.model.Backend; -import io.weaviate.client.v1.backup.model.BackupCreateResponse; -import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreResponse; -import io.weaviate.client.v1.backup.model.BackupRestoreStatusResponse; -import io.weaviate.client.v1.backup.model.CreateStatus; -import io.weaviate.client.v1.backup.model.RestoreStatus; -import io.weaviate.client.v1.graphql.model.GraphQLResponse; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.users.model.UserDb; - -public class BackupTestSuite { - - public static final String DOCKER_COMPOSE_BACKUPS_DIR = "/tmp/backups"; - public static final String CLASS_NAME_PIZZA = "Pizza"; - public static final String CLASS_NAME_SOUP = "Soup"; - public static final String NOT_EXISTING_CLASS_NAME = "not-existing-class"; - public static final String BACKEND = Backend.FILESYSTEM; - public static final String NOT_EXISTING_BACKEND = "not-existing-backend"; - - public static void testCreateAndRestoreBackupWithWaiting(Supplier> supplierCreate, - Supplier> supplierCreateStatus, - Supplier> supplierRestore, - Supplier> supplierRestoreStatus, - Supplier> supplierDeleteClass, - Function> supplierGQLOfClass, - String backupId) { - assertThatAllPizzasExist(supplierGQLOfClass); - - // Create backup - Result createResult = supplierCreate.get(); - - assertThat(createResult.getError()).as("create backup").isNull(); - assertThat(createResult.getResult()).isNotNull() - .returns(backupId, BackupCreateResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupCreateResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateResponse::getPath) - .returns(BACKEND, BackupCreateResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateResponse::getStatus) - .returns(null, BackupCreateResponse::getError); - - assertThatAllPizzasExist(supplierGQLOfClass); - - // Check backup status - Result createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.getError()).as("check backup creation status").isNull(); - assertThat(createStatusResult.getResult()).isNotNull() - .returns(backupId, BackupCreateStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateStatusResponse::getPath) - .returns(BACKEND, BackupCreateStatusResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateStatusResponse::getStatus) - .returns(null, BackupCreateStatusResponse::getError); - - // Remove existing class - Result delete = supplierDeleteClass.get(); - - assertThat(delete.getError()).as("drop Pizza collection").isNull(); - assertThat(delete.getResult()).isTrue(); - - // Restore backup - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.getError()).as("restore from backup").isNull(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupRestoreResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreResponse::getPath) - .returns(BACKEND, BackupRestoreResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreResponse::getStatus) - .returns(null, BackupRestoreResponse::getError); - - assertThatAllPizzasExist(supplierGQLOfClass); - - // Check restore backup - Result restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.getError()).as("get restore status").isNull(); - assertThat(restoreStatusResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreStatusResponse::getPath) - .returns(BACKEND, BackupRestoreStatusResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreStatusResponse::getStatus) - .returns(null, BackupRestoreStatusResponse::getError); - } - - public static void testCreateWithDynamicLocation(Supplier> supplierCreate, - Supplier> supplierCreateStatus, - Supplier> supplierRestore, - Supplier> supplierRestoreStatus, - Supplier> supplierDeleteClass, - Function> supplierGQLOfClass, - String backupId, String bucket, String path) throws InterruptedException { - assertThatAllPizzasExist(supplierGQLOfClass); - String wantFullPath = Paths.get(path, backupId).toString(); - - Result createResult = supplierCreate.get(); - assertThat(createResult.getError()).as("create backup").isNull(); - assertThat(createResult.getResult()).isNotNull() - .returns(backupId, BackupCreateResponse::getId) - .returns(wantFullPath, BackupCreateResponse::getPath).as("path in BackupCreateResponse"); - - // Wait until created - Result createStatusResult; - while (true) { - createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.getError()).as("check backup creation status").isNull(); - assertThat(createStatusResult.getResult()).isNotNull() - .returns(backupId, BackupCreateStatusResponse::getId) - .returns(wantFullPath, BackupCreateStatusResponse::getPath) - .extracting(BackupCreateStatusResponse::getStatus) - .isIn(CreateStatus.STARTED, CreateStatus.TRANSFERRING, CreateStatus.TRANSFERRED, CreateStatus.SUCCESS); - - if (CreateStatus.SUCCESS.equals(createStatusResult.getResult().getStatus())) { - break; - } - Thread.sleep(100); - } - - // Delete all data to then restore it from backup. - Result delete = supplierDeleteClass.get(); - assertThat(delete.getError()).as("drop Pizza collection").isNull(); - assertThat(delete.getResult()).isTrue(); - - Result restoreResult = supplierRestore.get(); - assertThat(restoreResult.getError()).as("restore from backup").isNull(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(wantFullPath, BackupRestoreResponse::getPath); - - // Wait until restored - Result restoreStatusResult; - while (true) { - restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.getError()).as("get restore status").isNull(); - assertThat(restoreStatusResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreStatusResponse::getId) - .returns(wantFullPath, BackupRestoreStatusResponse::getPath) - .extracting(BackupRestoreStatusResponse::getStatus) - .isIn(RestoreStatus.STARTED, RestoreStatus.TRANSFERRING, RestoreStatus.TRANSFERRED, RestoreStatus.SUCCESS); - - if (RestoreStatus.SUCCESS.equals(restoreStatusResult.getResult().getStatus())) { - break; - } - Thread.sleep(100); - } - - assertThatAllPizzasExist(supplierGQLOfClass); - } - - public static void testCreateAndRestoreBackupWithoutWaiting(Supplier> supplierCreate, - Supplier> supplierCreateStatus, - Supplier> supplierRestore, - Supplier> supplierRestoreStatus, - Supplier> supplierDeleteClass, - Function> supplierGQLOfClass, - String backupId) throws InterruptedException { - assertThatAllPizzasExist(supplierGQLOfClass); - - // Start creating backup - Result createResult = supplierCreate.get(); - - assertThat(createResult.getError()).as("create backup").isNull(); - assertThat(createResult.getResult()).isNotNull() - .returns(backupId, BackupCreateResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupCreateResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateResponse::getPath) - .returns(BACKEND, BackupCreateResponse::getBackend) - .returns(CreateStatus.STARTED, BackupCreateResponse::getStatus) - .returns(null, BackupCreateResponse::getError); - - // Wait until created - Result createStatusResult; - while (true) { - createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.getError()).as("check backup creation status").isNull(); - assertThat(createStatusResult.getResult()).isNotNull() - .returns(backupId, BackupCreateStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateStatusResponse::getPath) - .returns(BACKEND, BackupCreateStatusResponse::getBackend) - .returns(null, BackupCreateStatusResponse::getError) - .extracting(BackupCreateStatusResponse::getStatus).isIn(CreateStatus.STARTED, CreateStatus.TRANSFERRING, - CreateStatus.TRANSFERRED, CreateStatus.SUCCESS); - - if (CreateStatus.SUCCESS.equals(createStatusResult.getResult().getStatus())) { - break; - } - Thread.sleep(100); - } - - assertThatAllPizzasExist(supplierGQLOfClass); - - // Remove existing class - Result delete = supplierDeleteClass.get(); - - assertThat(delete.getError()).as("drop Pizza collection").isNull(); - assertThat(delete.getResult()).isTrue(); - - // Start restoring backup - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.getError()).as("restore from backup").isNull(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupRestoreResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreResponse::getPath) - .returns(BACKEND, BackupRestoreResponse::getBackend) - .returns(RestoreStatus.STARTED, BackupRestoreResponse::getStatus) - .returns(null, BackupRestoreResponse::getError); - - // Wait until restored - Result restoreStatusResult; - while (true) { - restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.getError()).as("get restore status").isNull(); - assertThat(restoreStatusResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreStatusResponse::getPath) - .returns(BACKEND, BackupRestoreStatusResponse::getBackend) - .returns(null, BackupRestoreStatusResponse::getError) - .extracting(BackupRestoreStatusResponse::getStatus).isIn(RestoreStatus.STARTED, RestoreStatus.TRANSFERRING, - RestoreStatus.TRANSFERRED, RestoreStatus.SUCCESS); - - if (RestoreStatus.SUCCESS.equals(restoreStatusResult.getResult().getStatus())) { - break; - } - Thread.sleep(100); - } - - assertThatAllPizzasExist(supplierGQLOfClass); - } - - public static void testCreateAndRestore1Of2Classes(Supplier> supplierCreate, - Supplier> supplierCreateStatus, - Supplier> supplierRestore, - Supplier> supplierRestoreStatus, - Supplier> supplierDeleteClass, - Function> supplierGQLOfClass, - String backupId) { - assertThatAllPizzasExist(supplierGQLOfClass); - assertThatAllSoupsExist(supplierGQLOfClass); - - // Create backup for all existing classes (2) - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - assertThat(createResult.getResult()).isNotNull() - .returns(backupId, BackupCreateResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateResponse::getPath) - .returns(BACKEND, BackupCreateResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateResponse::getStatus) - .returns(null, BackupCreateResponse::getError) - .extracting(BackupCreateResponse::getClassNames).asInstanceOf(ARRAY) - .containsExactlyInAnyOrder(CLASS_NAME_PIZZA, CLASS_NAME_SOUP); - - assertThatAllPizzasExist(supplierGQLOfClass); - assertThatAllSoupsExist(supplierGQLOfClass); - - // Check backup status - Result createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.hasErrors()).isFalse(); - assertThat(createStatusResult.getResult()).isNotNull() - .returns(backupId, BackupCreateStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateStatusResponse::getPath) - .returns(BACKEND, BackupCreateStatusResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateStatusResponse::getStatus) - .returns(null, BackupCreateStatusResponse::getError); - - // Remove existing class - Result delete = supplierDeleteClass.get(); - - assertThat(delete.hasErrors()).isFalse(); - assertThat(delete.getResult()).isTrue(); - - // Restore backup - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isFalse(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupRestoreResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreResponse::getPath) - .returns(BACKEND, BackupRestoreResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreResponse::getStatus) - .returns(null, BackupRestoreResponse::getError); - - assertThatAllPizzasExist(supplierGQLOfClass); - assertThatAllSoupsExist(supplierGQLOfClass); - - // Check restore backup - Result restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.hasErrors()).isFalse(); - assertThat(restoreStatusResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreStatusResponse::getPath) - .returns(BACKEND, BackupRestoreStatusResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreStatusResponse::getStatus) - .returns(null, BackupRestoreStatusResponse::getError); - } - - public static void testListExistingBackups(List>> createSuppliers, - Supplier> supplierGet) { - // Create backups - createSuppliers.forEach(Supplier::get); - - // List backups - Result listResult = supplierGet.get(); - skipIfNotImplemented(listResult); - - assertThat(listResult.getError()).isNull(); - assertThat(listResult.getResult()).isNotNull() - .hasSizeGreaterThan(2); - } - - public static void testFailOnCreateBackupOnNotExistingBackend(Supplier> supplierCreate) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isTrue(); - assertThat(createResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(NOT_EXISTING_BACKEND); - } - - public static void testFailOnCreateBackupStatusOnNotExistingBackend( - Supplier> supplierCreateStatus) { - Result createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.hasErrors()).isTrue(); - assertThat(createStatusResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(NOT_EXISTING_BACKEND); - } - - public static void testFailOnRestoreBackupFromNotExistingBackend( - Supplier> supplierRestore) { - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isTrue(); - assertThat(restoreResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(NOT_EXISTING_BACKEND); - } - - public static void testFailOnCreateBackupForNotExistingClass(Supplier> supplierCreate) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isTrue(); - assertThat(createResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(NOT_EXISTING_CLASS_NAME); - } - - public static void testFailOnRestoreBackupForExistingClass(Supplier> supplierCreate, - Supplier> supplierRestore, - String backupId) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isFalse(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreResponse::getPath) - .returns(BACKEND, BackupRestoreResponse::getBackend) - .returns(RestoreStatus.FAILED, BackupRestoreResponse::getStatus) - .extracting(BackupRestoreResponse::getError, InstanceOfAssertFactories.STRING) - .contains("could not restore classes"); - } - - public static void testFailOnCreateOfExistingBackup(Supplier> supplierCreate, - String backupId) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - - Result createResultAgain = supplierCreate.get(); - - assertThat(createResultAgain.hasErrors()).isTrue(); - assertThat(createResultAgain.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(backupId); - } - - public static void testFailOnCreateStatusOfNotExistingBackup( - Supplier> supplierCreateStatus, - String backupId) { - Result createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.hasErrors()).isTrue(); - assertThat(createStatusResult.getError()).isNotNull() - .returns(HttpStatus.SC_NOT_FOUND, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(backupId); - } - - public static void testFailOnRestoreOfNotExistingBackup(Supplier> supplierRestore, - String backupId) { - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isTrue(); - assertThat(restoreResult.getError()).isNotNull() - .returns(HttpStatus.SC_NOT_FOUND, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(backupId); - } - - public static void testFailOnRestoreBackupStatusOfNotStartedRestore( - Supplier> supplierCreate, - Supplier> supplierRestoreStatus, - String backupId) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - - Result restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.hasErrors()).isTrue(); - assertThat(restoreStatusResult.getError()).isNotNull() - .returns(HttpStatus.SC_NOT_FOUND, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains(backupId); - } - - public static void testFailOnCreateBackupForBothIncludeAndExcludeClasses( - Supplier> supplierCreate) { - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isTrue(); - assertThat(createResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains("include").contains("exclude"); - } - - public static void testFailOnRestoreBackupForBothIncludeAndExcludeClasses( - Supplier> supplierCreate, - Supplier> supplierRestore, - Supplier> supplierDeleteClass) { - // Create backup - Result createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - - // Remove existing class - Result delete = supplierDeleteClass.get(); - - assertThat(delete.hasErrors()).isFalse(); - - // Restore - Result restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isTrue(); - assertThat(restoreResult.getError()).isNotNull() - .returns(HttpStatus.SC_UNPROCESSABLE_ENTITY, WeaviateError::getStatusCode) - .extracting(WeaviateError::getMessages).asList() - .hasSizeGreaterThan(0) - .extracting(msg -> ((WeaviateErrorMessage) msg).getMessage()) - .first().asInstanceOf(CHAR_SEQUENCE).contains("include").contains("exclude"); - } - - public static void testCreateAndRestoreBackupWithWaitingWithConfig( - Supplier> supplierCreateInvConfig, - Supplier> supplierCreate, - Supplier> supplierCreateStatus, - Supplier> supplierRestoreInvConfig, - Supplier> supplierRestore, - Supplier> supplierRestoreStatus, - Supplier> supplierDeleteClass, - Function> supplierGQLOfClass, - String backupId) { - assertThatAllPizzasExist(supplierGQLOfClass); - - // Try to create with too high value - Result createResult = supplierCreateInvConfig.get(); - - assertThat(createResult).isNotNull() - .extracting(Result::getError).isNotNull() - .extracting(WeaviateError::getMessages) - .satisfies(errors -> assertThat(errors.stream().filter(m -> m.getMessage().contains("CPUPercentage")).count()) - .isGreaterThanOrEqualTo(1)); - - // Create backup - createResult = supplierCreate.get(); - - assertThat(createResult.hasErrors()).isFalse(); - assertThat(createResult.getResult()).isNotNull() - .returns(backupId, BackupCreateResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupCreateResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateResponse::getPath) - .returns(BACKEND, BackupCreateResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateResponse::getStatus) - .returns(null, BackupCreateResponse::getError); - - assertThatAllPizzasExist(supplierGQLOfClass); - - // Check backup status - Result createStatusResult = supplierCreateStatus.get(); - - assertThat(createStatusResult.hasErrors()).isFalse(); - assertThat(createStatusResult.getResult()).isNotNull() - .returns(backupId, BackupCreateStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupCreateStatusResponse::getPath) - .returns(BACKEND, BackupCreateStatusResponse::getBackend) - .returns(CreateStatus.SUCCESS, BackupCreateStatusResponse::getStatus) - .returns(null, BackupCreateStatusResponse::getError); - - // Remove existing class - Result delete = supplierDeleteClass.get(); - - assertThat(delete.hasErrors()).isFalse(); - assertThat(delete.getResult()).isTrue(); - - // Try to restore with bad restore config - Result restoreResult = supplierRestoreInvConfig.get(); - - assertThat(restoreResult).isNotNull() - .extracting(Result::getError).isNotNull() - .extracting(WeaviateError::getMessages).isNotNull() - .satisfies(errors -> assertThat(errors.stream().filter(m -> m.getMessage().contains("CPUPercentage")).count()) - .isGreaterThanOrEqualTo(1)); - - // Restore backup - restoreResult = supplierRestore.get(); - - assertThat(restoreResult.hasErrors()).isFalse(); - assertThat(restoreResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreResponse::getId) - .returns(new String[] { CLASS_NAME_PIZZA }, BackupRestoreResponse::getClassNames) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreResponse::getPath) - .returns(BACKEND, BackupRestoreResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreResponse::getStatus) - .returns(null, BackupRestoreResponse::getError); - - assertThatAllPizzasExist(supplierGQLOfClass); - - // Check restore backup - Result restoreStatusResult = supplierRestoreStatus.get(); - - assertThat(restoreStatusResult.hasErrors()).isFalse(); - assertThat(restoreStatusResult.getResult()).isNotNull() - .returns(backupId, BackupRestoreStatusResponse::getId) - .returns(DOCKER_COMPOSE_BACKUPS_DIR + "/" + backupId, BackupRestoreStatusResponse::getPath) - .returns(BACKEND, BackupRestoreStatusResponse::getBackend) - .returns(RestoreStatus.SUCCESS, BackupRestoreStatusResponse::getStatus) - .returns(null, BackupRestoreStatusResponse::getError); - } - - public static void testCancelBackup(Supplier> supplierCreate, - Supplier> supplierCancel, - Supplier> supplierCreateStatus) { - Result createResult = supplierCreate.get(); - assertThat(createResult.getError()).as("start backup").isNull(); - - Result cancelResult = supplierCancel.get(); - assertThat(cancelResult.getError()).as("cancel backup").isNull(); - - waitForCreateStatus(supplierCreateStatus, CreateStatus.CANCELED); - } - - public static void testBackupRestoreWithRbacOptions(String backupId, - Runnable arrange, - Runnable delete, - Supplier> supplierCreate, - Supplier> supplierRestore, - Supplier> supplierUser, - Supplier> supplierRole) { - - // Arrange - arrange.run(); - - // Act - Result createBackup = supplierCreate.get(); - assertThat(createBackup.getError()).as("create backup").isNull(); - assertThat(createBackup.getResult().getStatus()) - .as("create backup status: " + createBackup.getResult().getError()).isEqualTo("SUCCESS"); - - delete.run(); - - Result restoreBackup = supplierRestore.get(); - assertThat(restoreBackup.getError()).as("restore backup").isNull(); - assertThat(restoreBackup.getResult().getStatus()) - .as("restore backup status: " + restoreBackup.getResult().getError()).isEqualTo("SUCCESS"); - - // Assert - assertThat(supplierUser.get().getResult()).as("get restored user").isNotNull(); - assertThat(supplierRole.get().getResult()).as("get restored role").isNotNull(); - - } - - public static void testOverwriteAlias_true( - Runnable arrange, - Callable> act, - Supplier supplierAlias, String wantClassName) throws Exception { - arrange.run(); - Result result = act.call(); - assertThat(result.getError()).isNull(); - assertThat(supplierAlias.get().getClassName()).isEqualTo(wantClassName); - } - - private static void assertThatAllPizzasExist(Function> supplierGQLOfClass) { - assertThatAllFoodObjectsExist(supplierGQLOfClass, "Pizza", "Quattro Formaggi", "Frutti di Mare", "Hawaii", - "Doener"); - } - - private static void assertThatAllSoupsExist(Function> supplierGQLOfClass) { - assertThatAllFoodObjectsExist(supplierGQLOfClass, "Soup", "ChickenSoup", "Beautiful"); - } - - private static void assertThatAllFoodObjectsExist(Function> supplierGQLOfClass, - String className, String... names) { - Result result = supplierGQLOfClass.apply(className); - - assertThat(result.hasErrors()).isFalse(); - assertThat(result.getResult()).isNotNull() - .extracting(GraphQLResponse::getData).isInstanceOf(Map.class) - .extracting(data -> ((Map) data).get("Get")).isInstanceOf(Map.class) - .extracting(get -> ((Map) get).get(className)).asList() - .hasSize(names.length).hasOnlyElementsOfType(Map.class) - .extracting(pizza -> ((Map) pizza).get("name")).hasOnlyElementsOfType(String.class) - .extracting(name -> (String) name) - .containsExactlyInAnyOrder(names); - } - - /** - * Periodically polls backup creation status until it reaches the desired - * ({@code want}) state or the deadline expires. - * - *
- * Interval: 100ms - *
- * Timeout: 5s - */ - private static void waitForCreateStatus(Supplier> supplierCreateStatus, - String want) { - final int MAX_RETRIES = 5_000 / 100; - AtomicReference status = new AtomicReference<>(""); - - Callable statusCheck = () -> { - Result check = supplierCreateStatus.get(); - String current = check.getResult().getStatus(); - status.set(current); - return current.equalsIgnoreCase(want); - }; - - try { - int retried = 0; - do { - if (statusCheck.call()) { - return; - } - retried++; - Thread.sleep(100); - } while (retried < MAX_RETRIES); - } catch (Exception ignored) { - } - fail(String.format("after 5s create status: want=%s, got=%s", want, status.get())); - } - - /** - * Skip a test if the operation is not implemented on the server. - * - *

- * We assume that in such cases the server will return an response with body - * "not implemented"; - * this is not a good reason to fail the client's test. - * - * @param result Any Result object from a request. - */ - private static void skipIfNotImplemented(Result result) { - if (result.hasErrors()) { - assumeTrue( - "this operation is not implemented on the server", - result.getError().getMessages().stream() - .noneMatch(err -> err.getMessage().toLowerCase().contains("not implemented"))); - } - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsMockServerTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsMockServerTestSuite.java deleted file mode 100644 index 4969cf0d4..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsMockServerTestSuite.java +++ /dev/null @@ -1,183 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponseStatus; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; - -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.time.ZonedDateTime; -import java.time.temporal.ChronoUnit; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static org.assertj.core.api.Assertions.assertThat; - -public class BatchObjectsMockServerTestSuite { - - public static final String PIZZA_1_ID = "abefd256-8574-442b-9293-9205193737ee"; - private static final Map PIZZA_1_PROPS = createFoodProperties( - "Hawaii", "Universally accepted to be the best pizza ever created."); - public static final String PIZZA_2_ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - private static final Map PIZZA_2_PROPS = createFoodProperties( - "Doener", "A innovation, some say revolution, in the pizza industry."); - public static final String SOUP_1_ID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - private static final Map SOUP_1_PROPS = createFoodProperties( - "ChickenSoup", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - public static final String SOUP_2_ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - private static final Map SOUP_2_PROPS = createFoodProperties( - "Beautiful", "Putting the game of letter soups to a whole new level."); - - public static final WeaviateObject PIZZA_1 = WeaviateObject.builder().className("Pizza").id(PIZZA_1_ID).properties(PIZZA_1_PROPS).build(); - public static final WeaviateObject PIZZA_2 = WeaviateObject.builder().className("Pizza").id(PIZZA_2_ID).properties(PIZZA_2_PROPS).build(); - public static final WeaviateObject SOUP_1 = WeaviateObject.builder().className("Soup").id(SOUP_1_ID).properties(SOUP_1_PROPS).build(); - public static final WeaviateObject SOUP_2 = WeaviateObject.builder().className("Soup").id(SOUP_2_ID).properties(SOUP_2_PROPS).build(); - - - public static void testNotCreateBatchDueToConnectionIssue(Supplier> supplierObjectsBatcher, - long expectedExecMinMillis, long expectedExecMaxMillis) { - ZonedDateTime start = ZonedDateTime.now(); - Result resBatch = supplierObjectsBatcher.get(); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(expectedExecMinMillis, expectedExecMaxMillis); - assertThat(resBatch.getResult()).isNull(); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains(PIZZA_1_ID, PIZZA_2_ID, SOUP_1_ID, SOUP_2_ID); - } - - public static void testNotCreateAutoBatchDueToConnectionIssue(Consumer>> supplierObjectsBatcher, - long expectedExecMinMillis, long expectedExecMaxMillis) { - List> resBatches = Collections.synchronizedList(new ArrayList<>(2)); - - ZonedDateTime start = ZonedDateTime.now(); - supplierObjectsBatcher.accept(resBatches::add); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(expectedExecMinMillis, expectedExecMaxMillis); - assertThat(resBatches).hasSize(2); - - for (Result resBatch : resBatches) { - assertThat(resBatch.getResult()).isNull(); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedIdsMessage = errorMessages.get(1).getMessage(); - if (failedIdsMessage.contains(PIZZA_1_ID)) { - assertThat(failedIdsMessage).contains(PIZZA_1_ID, PIZZA_2_ID).doesNotContain(SOUP_1_ID, SOUP_2_ID); - } else { - assertThat(failedIdsMessage).contains(SOUP_1_ID, SOUP_2_ID).doesNotContain(PIZZA_1_ID, PIZZA_2_ID); - } - } - } - - public static void testNotCreateBatchDueToTimeoutIssue(Supplier> supplierObjectsBatcher, - Consumer assertPostObjectsCallsCount, - Consumer assertGetPizza1CallsCount, - Consumer assertGetPizza2CallsCount, - Consumer assertGetSoup1CallsCount, - Consumer assertGetSoup2CallsCount, - int expectedBatchCallsCount, String expectedErr) { - Result resBatch = supplierObjectsBatcher.get(); - - assertPostObjectsCallsCount.accept(expectedBatchCallsCount); - assertGetPizza2CallsCount.accept(expectedBatchCallsCount); - assertGetSoup2CallsCount.accept(expectedBatchCallsCount); - assertGetPizza1CallsCount.accept(1); - assertGetSoup1CallsCount.accept(1); - - assertThat(resBatch.getResult()).hasSize(2); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains(expectedErr); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains(PIZZA_2_ID, SOUP_2_ID).doesNotContain(PIZZA_1_ID, SOUP_1_ID); - - assertThat(resBatch.getResult()[0]) - .returns(PIZZA_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - assertThat(resBatch.getResult()[1]) - .returns(SOUP_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } - - public static void testNotCreateAutoBatchDueToTimeoutIssue(Consumer>> supplierObjectsBatcher, - Consumer assertPostObjectsCallsCount, - Consumer assertGetPizza1CallsCount, - Consumer assertGetPizza2CallsCount, - Consumer assertGetSoup1CallsCount, - Consumer assertGetSoup2CallsCount, - int expectedBatchCallsCount, String expectedErr) { - List> resBatches = Collections.synchronizedList(new ArrayList<>(2)); - supplierObjectsBatcher.accept(resBatches::add); - - assertPostObjectsCallsCount.accept(expectedBatchCallsCount * 2); - assertGetPizza2CallsCount.accept(expectedBatchCallsCount); - assertGetSoup2CallsCount.accept(expectedBatchCallsCount); - assertGetPizza1CallsCount.accept(1); - assertGetSoup1CallsCount.accept(1); - - assertThat(resBatches).hasSize(2); - for (Result resBatch : resBatches) { - assertThat(resBatch.getResult()).hasSize(1); - assertThat(resBatch.hasErrors()).isTrue(); - - List errorMessages = resBatch.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains(expectedErr); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedIdsMessage = errorMessages.get(1).getMessage(); - if (failedIdsMessage.contains(PIZZA_2_ID)) { - assertThat(failedIdsMessage).contains(PIZZA_2_ID).doesNotContain(PIZZA_1_ID, SOUP_1_ID, SOUP_2_ID); - assertThat(resBatch.getResult()[0]) - .returns(PIZZA_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } else { - assertThat(failedIdsMessage).contains(SOUP_2_ID).doesNotContain(PIZZA_1_ID, PIZZA_2_ID, SOUP_1_ID); - assertThat(resBatch.getResult()[0]) - .returns(SOUP_1_ID, ObjectGetResponse::getId) - .extracting(ObjectGetResponse::getResult).isNotNull() - .returns(ObjectGetResponseStatus.SUCCESS, ObjectsGetResponseAO2Result::getStatus) - .returns(null, ObjectsGetResponseAO2Result::getErrors); - } - } - } - - private static Map createFoodProperties(String name, String description) { - Map props = new HashMap<>(); - props.put("name", name); - props.put("description", description); - - return props; - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsTestSuite.java deleted file mode 100644 index dddc996e1..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/BatchObjectsTestSuite.java +++ /dev/null @@ -1,180 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -import static org.assertj.core.api.Assertions.assertThat; - -public class BatchObjectsTestSuite { - - public static final String PIZZA_1_ID = "abefd256-8574-442b-9293-9205193737ee"; - public static final Map PIZZA_1_PROPS = createFoodProperties( - "Hawaii", "Universally accepted to be the best pizza ever created."); - public static final String PIZZA_2_ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - public static final Map PIZZA_2_PROPS = createFoodProperties( - "Doener", "A innovation, some say revolution, in the pizza industry."); - public static final String SOUP_1_ID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static final Map SOUP_1_PROPS = createFoodProperties( - "ChickenSoup", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - public static final String SOUP_2_ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - public static final Map SOUP_2_PROPS = createFoodProperties( - "Beautiful", "Putting the game of letter soups to a whole new level."); - - public static void testCreateBatch(Function> supplierObjectsBatcherPizzas, - Function> supplierObjectBatcherSoups, - Supplier> supplierDataPizza1, - Supplier> supplierDataSoup1, - Supplier>> supplierGetterPizza1, - Supplier>> supplierGetterPizza2, - Supplier>> supplierGetterSoup1, - Supplier>> supplierGetterSoup2) { - // when - Result resPizza1 = supplierDataPizza1.get(); - Result resSoup1 = supplierDataSoup1.get(); - - assertThat(resPizza1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - assertThat(resSoup1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - Result resBatchPizzas = supplierObjectsBatcherPizzas.apply(resPizza1.getResult()); - Result resBatchSoups = supplierObjectBatcherSoups.apply(resSoup1.getResult()); - - assertThat(resBatchPizzas).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resBatchPizzas.getResult()).hasSize(2); - assertThat(resBatchSoups).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resBatchSoups.getResult()).hasSize(2); - - // check if created objects exist - Result> resGetPizza1 = supplierGetterPizza1.get(); - Result> resGetPizza2 = supplierGetterPizza2.get(); - Result> resGetSoup1 = supplierGetterSoup1.get(); - Result> resGetSoup2 = supplierGetterSoup2.get(); - - assertThat(resGetPizza1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(PIZZA_1_ID); - assertThat(resGetPizza2).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(PIZZA_2_ID); - assertThat(resGetSoup1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(SOUP_1_ID); - assertThat(resGetSoup2).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(SOUP_2_ID); - } - - public static void testCreateAutoBatch( - BiConsumer>> supplierObjectsBatcherPizzas, - BiConsumer>> supplierObjectsBatcherSoups, - Supplier> supplierDataPizza1, - Supplier> supplierDataSoup1, - Supplier>> supplierGetterPizza1, - Supplier>> supplierGetterPizza2, - Supplier>> supplierGetterSoup1, - Supplier>> supplierGetterSoup2) { - // when - Result resPizza1 = supplierDataPizza1.get(); - Result resSoup1 = supplierDataSoup1.get(); - - assertThat(resPizza1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - assertThat(resSoup1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull(); - - List> resBatches = Collections.synchronizedList(new ArrayList<>(2)); - supplierObjectsBatcherPizzas.accept(resPizza1.getResult(), resBatches::add); - supplierObjectsBatcherSoups.accept(resSoup1.getResult(), resBatches::add); - - assertThat(resBatches.get(0)).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resBatches.get(0).getResult()).hasSize(2); - assertThat(resBatches.get(1)).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resBatches.get(1).getResult()).hasSize(2); - - // check if created objects exist - Result> resGetPizza1 = supplierGetterPizza1.get(); - Result> resGetPizza2 = supplierGetterPizza2.get(); - Result> resGetSoup1 = supplierGetterSoup1.get(); - Result> resGetSoup2 = supplierGetterSoup2.get(); - - assertThat(resGetPizza1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(PIZZA_1_ID); - assertThat(resGetPizza2).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(PIZZA_2_ID); - assertThat(resGetSoup1).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(SOUP_1_ID); - assertThat(resGetSoup2).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asList().hasSize(1) - .extracting(o -> ((WeaviateObject) o).getId()).first().isEqualTo(SOUP_2_ID); - } - - public static void testCreateBatchWithPartialError(Supplier> supplierObjectsBatcherPizzas, - Supplier>> supplierGetterPizza1, - Supplier>> supplierGetterPizza2) { - Result resBatch = supplierObjectsBatcherPizzas.get(); - assertThat(resBatch).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resBatch.getResult()).hasSize(2); - - ObjectGetResponse resPizzaWithError = resBatch.getResult()[0]; - assertThat(resPizzaWithError.getId()).isEqualTo(PIZZA_1_ID); - assertThat(resPizzaWithError.getResult().getErrors()) - .extracting(ObjectsGetResponseAO2Result.ErrorResponse::getError).asList() - .first() - .extracting(i -> ((ObjectsGetResponseAO2Result.ErrorItem) i).getMessage()).asString() - .contains("invalid text property 'name' on class 'Pizza': not a string, but json.Number"); - ObjectGetResponse resPizza = resBatch.getResult()[1]; - assertThat(resPizza.getId()).isEqualTo(PIZZA_2_ID); - assertThat(resPizza.getResult().getErrors()).isNull(); - - Result> resGetPizzaWithError = supplierGetterPizza1.get(); - Result> resGetPizza = supplierGetterPizza2.get(); - - assertThat(resGetPizzaWithError).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resGetPizzaWithError.getResult()).isNull(); - assertThat(resGetPizza).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resGetPizza.getResult()).hasSize(1); - } - - public static Map createFoodProperties(Object name, Object description) { - Map props = new HashMap<>(); - props.put("name", name); - props.put("description", description); - - return props; - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesMockServerTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesMockServerTestSuite.java deleted file mode 100644 index 52b891b57..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesMockServerTestSuite.java +++ /dev/null @@ -1,129 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; - -import java.net.ConnectException; -import java.net.SocketTimeoutException; -import java.time.ZonedDateTime; -import java.time.temporal.ChronoUnit; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static org.assertj.core.api.Assertions.assertThat; - -public class BatchReferencesMockServerTestSuite { - public static final String PIZZA_ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - public static final String SOUP_ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - public static final String FROM_PIZZA = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", PIZZA_ID); - public static final String FROM_SOUP = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", SOUP_ID); - public static final String TO_PIZZA = String.format("weaviate://localhost/%s/%s", "Pizza", PIZZA_ID); - public static final String TO_SOUP = String.format("weaviate://localhost/%s/%s", "Soup", SOUP_ID); - - - public static void testNotCreateBatchReferencesDueToConnectionIssue(Supplier> supplierReferencesBatcher, - long execMin, long execMax) { - ZonedDateTime start = ZonedDateTime.now(); - Result resReferences = supplierReferencesBatcher.get(); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(execMin, execMax); - assertThat(resReferences.getResult()).isNull(); - assertThat(resReferences.hasErrors()).isTrue(); - - List errorMessages = resReferences.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains( - FROM_PIZZA + " => " + TO_SOUP, - FROM_SOUP + " => " + TO_PIZZA, - FROM_PIZZA + " => " + TO_PIZZA, - FROM_SOUP + " => " + TO_SOUP - ); - } - - public static void testNotCreateAutoBatchReferencesDueToConnectionIssue(Consumer>> supplierReferencesBatcher, - long execMin, long execMax) { - List> resultsReferences = Collections.synchronizedList(new ArrayList<>(2)); - - ZonedDateTime start = ZonedDateTime.now(); - supplierReferencesBatcher.accept(resultsReferences::add); - ZonedDateTime end = ZonedDateTime.now(); - - assertThat(ChronoUnit.MILLIS.between(start, end)).isBetween(execMin, execMax); - assertThat(resultsReferences).hasSize(2); - for (Result resReferences : resultsReferences) { - assertThat(resReferences.getResult()).isNull(); - assertThat(resReferences.hasErrors()).isTrue(); - - List errorMessages = resReferences.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(ConnectException.class); - assertThat(errorMessages.get(0).getMessage()).contains("Connection refused"); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedRefsMessage = errorMessages.get(1).getMessage(); - if (failedRefsMessage.contains(FROM_PIZZA + " => " + TO_SOUP)) { - assertThat(failedRefsMessage).contains(FROM_PIZZA + " => " + TO_SOUP, FROM_SOUP + " => " + TO_PIZZA); - } else { - assertThat(failedRefsMessage).contains(FROM_PIZZA + " => " + TO_PIZZA, FROM_SOUP + " => " + TO_SOUP); - } - } - } - - public static void testNotCreateBatchReferencesDueToTimeoutIssue(Supplier> supplierReferencesBatcher, - Consumer assertBatchCallsTimes, - int expectedBatchCalls, String expectedErr) { - Result resReferences = supplierReferencesBatcher.get(); - - assertBatchCallsTimes.accept(expectedBatchCalls); - assertThat(resReferences.getResult()).isNull(); - assertThat(resReferences.hasErrors()).isTrue(); - - List errorMessages = resReferences.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains(expectedErr); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - assertThat(errorMessages.get(1).getMessage()).contains( - FROM_PIZZA + " => " + TO_SOUP, - FROM_SOUP + " => " + TO_PIZZA, - FROM_PIZZA + " => " + TO_PIZZA, - FROM_SOUP + " => " + TO_SOUP - ); - } - - public static void testNotCreateAutoBatchReferencesDueToTimeoutIssue(Consumer>> supplierReferencesBatcher, - Consumer assertBatchCallsTimes, - int expectedBatchCalls, String expectedErr) { - List> resultsReferences = Collections.synchronizedList(new ArrayList<>(2)); - - supplierReferencesBatcher.accept(resultsReferences::add); - - assertBatchCallsTimes.accept(expectedBatchCalls * 2); - assertThat(resultsReferences).hasSize(2); - for (Result resReferences : resultsReferences) { - assertThat(resReferences.getResult()).isNull(); - assertThat(resReferences.hasErrors()).isTrue(); - - List errorMessages = resReferences.getError().getMessages(); - assertThat(errorMessages).hasSize(2); - assertThat(errorMessages.get(0).getThrowable()).isInstanceOf(SocketTimeoutException.class); - assertThat(errorMessages.get(0).getMessage()).contains(expectedErr); - assertThat(errorMessages.get(1).getThrowable()).isNull(); - - String failedRefsMessage = errorMessages.get(1).getMessage(); - if (failedRefsMessage.contains(FROM_PIZZA + " => " + TO_SOUP)) { - assertThat(failedRefsMessage).contains(FROM_PIZZA + " => " + TO_SOUP, FROM_SOUP + " => " + TO_PIZZA); - } else { - assertThat(failedRefsMessage).contains(FROM_PIZZA + " => " + TO_PIZZA, FROM_SOUP + " => " + TO_SOUP); - } - } - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesTestSuite.java deleted file mode 100644 index 7dc7b124a..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/BatchReferencesTestSuite.java +++ /dev/null @@ -1,161 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchReferenceResponse; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static org.assertj.core.api.Assertions.assertThat; - -public class BatchReferencesTestSuite { - public static final String PIZZA_ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - public static final Map PIZZA_PROPS = createFoodProperties("Doener", - "A innovation, some say revolution, in the pizza industry."); - public static final String SOUP_ID = "07473b34-0ab2-4120-882d-303d9e13f7af"; - public static final Map SOUP_PROPS = createFoodProperties("Beautiful", - "Putting the game of letter soups to a whole new level."); - - public static void testCreateBatchReferences(Supplier> supplierReferencesBatcher, - Supplier> supplierObjectsBatcher, - Supplier>> supplierGetterPizza, - Supplier>> supplierGetterSoup) { - // given - Result batchResult = supplierObjectsBatcher.get(); - assertThat(batchResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(batchResult.getResult()).hasSize(2); - - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", SOUP_ID); - - // when - Result refsResult = supplierReferencesBatcher.get(); - - // then - assertThat(refsResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(refsResult.getResult()).hasSize(4); - assertThat(refsResult.getResult()) - .extracting(BatchReferenceResponse::getFrom) - .containsExactlyInAnyOrder(fromPizza, fromPizza, fromSoup, fromSoup); - assertThat(refsResult.getResult()) - .extracting(BatchReferenceResponse::getTo) - .containsExactlyInAnyOrder(toPizza, toPizza, toSoup, toSoup); - - Result> pizzaResult = supplierGetterPizza.get(); - assertThat(pizzaResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(pizzaResult.getResult()).hasSize(1); - - WeaviateObject pizza = pizzaResult.getResult().get(0); - assertThat(pizza.getId()).isEqualTo(PIZZA_ID); - assertThat(pizza.getProperties()).isNotNull(); - - Object pizzaOtherFoods = pizza.getProperties().get("otherFoods"); - assertThat(pizzaOtherFoods).isNotNull() - .isInstanceOf(List.class) - .asList().hasSize(2) - .extracting(map -> ((Map) map).get("beacon")) - .containsExactlyInAnyOrder(toPizza, toSoup); - - Result> soupResult = supplierGetterSoup.get(); - assertThat(soupResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(soupResult.getResult()).hasSize(1); - - WeaviateObject soup = soupResult.getResult().get(0); - assertThat(soup.getId()).isEqualTo(SOUP_ID); - assertThat(soup.getProperties()).isNotNull(); - - Object soupOtherFoods = soup.getProperties().get("otherFoods"); - assertThat(soupOtherFoods).isNotNull() - .isInstanceOf(List.class) - .asList().hasSize(2) - .extracting(map -> ((Map) map).get("beacon")) - .containsExactlyInAnyOrder(toPizza, toSoup); - } - - public static void testCreateAutoBatchReferences(Consumer>> supplierReferencesBatcher, - Supplier> supplierObjectsBatcher, - Supplier>> supplierGetterPizza, - Supplier>> supplierGetterSoup) { - // given - Result batchResult = supplierObjectsBatcher.get(); - assertThat(batchResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(batchResult.getResult()).hasSize(2); - - String fromPizza = String.format("weaviate://localhost/%s/%s/otherFoods", "Pizza", PIZZA_ID); - String fromSoup = String.format("weaviate://localhost/%s/%s/otherFoods", "Soup", SOUP_ID); - String toPizza = String.format("weaviate://localhost/%s/%s", "Pizza", PIZZA_ID); - String toSoup = String.format("weaviate://localhost/%s/%s", "Soup", SOUP_ID); - List> resultsReferences = Collections.synchronizedList(new ArrayList<>(2)); - - // when - supplierReferencesBatcher.accept(resultsReferences::add); - - // then - assertThat(resultsReferences).hasSize(2); - for (Result resReferences : resultsReferences) { - assertThat(resReferences).isNotNull() - .returns(false, Result::hasErrors); - assertThat(resReferences.getResult()).hasSize(2); - assertThat(resReferences.getResult()) - .extracting(BatchReferenceResponse::getFrom) - .containsExactlyInAnyOrder(fromPizza, fromSoup); - assertThat(resReferences.getResult()) - .extracting(BatchReferenceResponse::getTo) - .containsExactlyInAnyOrder(toPizza, toSoup); - } - - Result> pizzaResult = supplierGetterPizza.get(); - assertThat(pizzaResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(pizzaResult.getResult()).hasSize(1); - - WeaviateObject pizza = pizzaResult.getResult().get(0); - assertThat(pizza.getId()).isEqualTo(PIZZA_ID); - assertThat(pizza.getProperties()).isNotNull(); - - Object pizzaOtherFoods = pizza.getProperties().get("otherFoods"); - assertThat(pizzaOtherFoods).isNotNull() - .isInstanceOf(List.class) - .asList().hasSize(2) - .extracting(map -> ((Map) map).get("beacon")) - .containsExactlyInAnyOrder(toPizza, toSoup); - - Result> soupResult = supplierGetterSoup.get(); - assertThat(soupResult).isNotNull() - .returns(false, Result::hasErrors); - assertThat(soupResult.getResult()).hasSize(1); - - WeaviateObject soup = soupResult.getResult().get(0); - assertThat(soup.getId()).isEqualTo(SOUP_ID); - assertThat(soup.getProperties()).isNotNull(); - - Object soupOtherFoods = soup.getProperties().get("otherFoods"); - assertThat(soupOtherFoods).isNotNull() - .isInstanceOf(List.class) - .asList().hasSize(2) - .extracting(map -> ((Map) map).get("beacon")) - .containsExactlyInAnyOrder(toPizza, toSoup); - } - - private static Map createFoodProperties(String name, String description) { - Map props = new HashMap<>(); - props.put("name", name); - props.put("description", description); - - return props; - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchDeleteTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/ClientBatchDeleteTestSuite.java deleted file mode 100644 index 8aed26e2e..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchDeleteTestSuite.java +++ /dev/null @@ -1,192 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.BatchDeleteOutput; -import io.weaviate.client.v1.batch.model.BatchDeleteResponse; -import io.weaviate.client.v1.batch.model.BatchDeleteResultStatus; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.data.replication.model.ConsistencyLevel; -import io.weaviate.client.v1.filters.Operator; -import io.weaviate.client.v1.filters.WhereFilter; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.time.Instant; -import java.util.List; -import java.util.function.Function; -import java.util.function.Supplier; -import static org.assertj.core.api.Assertions.assertThat; - -public class ClientBatchDeleteTestSuite { - public static void testBatchDeleteDryRunVerbose(Supplier>> getObjects, Function> batchDelete) { - // when - WhereFilter whereFilter = WhereFilter.builder() - .operator(Operator.Equal) - .path(new String[]{ "name" }) - .valueText("Hawaii") - .build(); - - int allWeaviateObjects = countWeaviateObjects(getObjects); - - Result resResponse = batchDelete.apply(whereFilter); - int remainingWeaviateObjects = countWeaviateObjects(getObjects); - - // then - assertThat(remainingWeaviateObjects).isEqualTo(allWeaviateObjects); - assertThat(resResponse).isNotNull(); - assertThat(resResponse.hasErrors()).isFalse(); - - BatchDeleteResponse response = resResponse.getResult(); - assertThat(response).isNotNull(); - assertThat(response.getDryRun()).isTrue(); - assertThat(response.getOutput()).isEqualTo(BatchDeleteOutput.VERBOSE); - - BatchDeleteResponse.Match match = response.getMatch(); - assertThat(match).isNotNull(); - assertThat(match.getClassName()).isEqualTo("Pizza"); - assertThat(match.getWhereFilter()).isEqualTo(whereFilter); - - BatchDeleteResponse.Results results = response.getResults(); - assertThat(results).isNotNull(); - assertThat(results.getSuccessful()).isZero(); - assertThat(results.getFailed()).isZero(); - assertThat(results.getLimit()).isEqualTo(10000L); - assertThat(results.getMatches()).isEqualTo(1L); - assertThat(results.getObjects()).hasSize(1); - - BatchDeleteResponse.ResultObject object = results.getObjects()[0]; - assertThat(object).isNotNull(); - assertThat(object.getId()).isEqualTo(WeaviateTestGenerics.PIZZA_HAWAII_ID); - assertThat(object.getStatus()).isEqualTo(BatchDeleteResultStatus.DRYRUN); - assertThat(object.getErrors()).isNull(); - } - - public static void testBatchDeleteDryRunMinimal(Supplier>> getObjects, Function> batchDelete) { - // when - WhereFilter whereFilter = WhereFilter.builder() - .operator(Operator.Like) - .path(new String[]{ "description" }) - .valueText("microscopic") - .build(); - - int allWeaviateObjects = countWeaviateObjects(getObjects); - Result resResponse = batchDelete.apply(whereFilter); - int remainingWeaviateObjects = countWeaviateObjects(getObjects); - - // then - assertThat(remainingWeaviateObjects).isEqualTo(allWeaviateObjects); - assertThat(resResponse).isNotNull(); - assertThat(resResponse.hasErrors()).isFalse(); - - BatchDeleteResponse response = resResponse.getResult(); - assertThat(response).isNotNull(); - assertThat(response.getDryRun()).isTrue(); - assertThat(response.getOutput()).isEqualTo(BatchDeleteOutput.MINIMAL); - - BatchDeleteResponse.Match match = response.getMatch(); - assertThat(match).isNotNull(); - assertThat(match.getClassName()).isEqualTo("Soup"); - assertThat(match.getWhereFilter()).isEqualTo(whereFilter); - - BatchDeleteResponse.Results results = response.getResults(); - assertThat(results).isNotNull(); - assertThat(results.getSuccessful()).isZero(); - assertThat(results.getFailed()).isZero(); - assertThat(results.getLimit()).isEqualTo(10000L); - assertThat(results.getMatches()).isEqualTo(1L); - assertThat(results.getObjects()).isNull(); - } - - public static void testBatchDeleteNoMatchWithDefaultOutputAndDryRun(Supplier>> getObjects, Function> batchDelete) { - // when - long inAMinute = Instant.now().plusSeconds(60).toEpochMilli(); - WhereFilter whereFilter = WhereFilter.builder() - .operator(Operator.GreaterThan) - .path(new String[]{ "_creationTimeUnix" }) - .valueText(Long.toString(inAMinute)) - .build(); - - int allWeaviateObjects = countWeaviateObjects(getObjects); - Result response = batchDelete.apply(whereFilter); - int remainingWeaviateObjects = countWeaviateObjects(getObjects); - - // then - assertThat(remainingWeaviateObjects).isEqualTo(allWeaviateObjects); - assertThat(response).isNotNull(); - assertThat(response.hasErrors()).isFalse(); - - BatchDeleteResponse result = response.getResult(); - assertThat(response.getResult()).isNotNull(); - assertThat(result.getDryRun()).isFalse(); - assertThat(result.getOutput()).isEqualTo(BatchDeleteOutput.MINIMAL); - - BatchDeleteResponse.Match match = result.getMatch(); - assertThat(match).isNotNull(); - assertThat(match.getClassName()).isEqualTo("Pizza"); - assertThat(match.getWhereFilter()).isEqualTo(whereFilter); - - BatchDeleteResponse.Results results = result.getResults(); - assertThat(results).isNotNull(); - assertThat(results.getSuccessful()).isZero(); - assertThat(results.getFailed()).isZero(); - assertThat(results.getLimit()).isEqualTo(10000L); - assertThat(results.getMatches()).isZero(); - assertThat(results.getObjects()).isNull(); - } - - public static void testBatchDeleteAllMatchesWithDefaultDryRun(Supplier>> getObjects, Function> batchDelete) { - // when - long inAMinute = Instant.now().plusSeconds(60).toEpochMilli(); - WhereFilter whereFilter = WhereFilter.builder() - .operator(Operator.LessThan) - .path(new String[]{ "_creationTimeUnix" }) - .valueText(Long.toString(inAMinute)) - .build(); - - int allWeaviateObjects = countWeaviateObjects(getObjects); - Result response = batchDelete.apply(whereFilter); - int remainingWeaviateObjects = countWeaviateObjects(getObjects); - - // then - assertThat(remainingWeaviateObjects).isEqualTo(allWeaviateObjects - 4); - assertThat(response).isNotNull(); - assertThat(response.hasErrors()).isFalse(); - - BatchDeleteResponse result = response.getResult(); - assertThat(response.getResult()).isNotNull(); - assertThat(result.getDryRun()).isFalse(); - assertThat(result.getOutput()).isEqualTo(BatchDeleteOutput.VERBOSE); - - BatchDeleteResponse.Match match = result.getMatch(); - assertThat(match).isNotNull(); - assertThat(match.getClassName()).isEqualTo("Pizza"); - assertThat(match.getWhereFilter()).isEqualTo(whereFilter); - - BatchDeleteResponse.Results results = result.getResults(); - assertThat(results).isNotNull(); - assertThat(results.getSuccessful()).isEqualTo(4); - assertThat(results.getFailed()).isZero(); - assertThat(results.getLimit()).isEqualTo(10000L); - assertThat(results.getMatches()).isEqualTo(4); - - BatchDeleteResponse.ResultObject[] objects = results.getObjects(); - assertThat(objects).hasSize(4); - assertThat(objects).doesNotContainNull(); - assertThat(objects).extracting(BatchDeleteResponse.ResultObject::getStatus) - .containsOnly(BatchDeleteResultStatus.SUCCESS); - assertThat(objects).extracting(BatchDeleteResponse.ResultObject::getErrors) - .containsOnlyNulls(); - assertThat(objects).extracting(BatchDeleteResponse.ResultObject::getId) - .contains(WeaviateTestGenerics.PIZZA_HAWAII_ID, WeaviateTestGenerics.PIZZA_DOENER_ID, - WeaviateTestGenerics.PIZZA_QUATTRO_FORMAGGI_ID, WeaviateTestGenerics.PIZZA_FRUTTI_DI_MARE_ID); - } - - private static int countWeaviateObjects(Supplier>> getObjects) { - Result> resResponse = getObjects.get(); - assertThat(resResponse).isNotNull(); - assertThat(resResponse.hasErrors()).isFalse(); - - List response = resResponse.getResult(); - assertThat(response).isNotNull(); - - return response.size(); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateNamedVectorsTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateNamedVectorsTestSuite.java deleted file mode 100644 index d9e827545..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateNamedVectorsTestSuite.java +++ /dev/null @@ -1,249 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.UUID; -import java.util.function.Function; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.batch.model.ObjectsGetResponseAO2Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.MultiVectorConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; - -public class ClientBatchGrpcCreateNamedVectorsTestSuite { - - public static void shouldCreateObjectsWithNamedVectors(Function> classCreate, - Function> batchCreate, - Function>> fetch, - Function> deleteClass) { - String className = "NamedVectors"; - List properties = Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder() - .name("title") - .dataType(Collections.singletonList(DataType.TEXT)) - .build()); - Map none = new HashMap<>(); - none.put("none", new Object()); - Map text2vecContextionary = new HashMap<>(); - Map text2vecContextionarySettings = new HashMap<>(); - text2vecContextionarySettings.put("vectorizeClassName", false); - text2vecContextionarySettings.put("properties", new String[] { "title" }); - text2vecContextionary.put("text2vec-contextionary", text2vecContextionarySettings); - Map vectorConfig = new HashMap<>(); - vectorConfig.put("hnswVector", WeaviateClass.VectorConfig.builder() - .vectorIndexType("hnsw") - .vectorizer(none) - .build()); - vectorConfig.put("c11y", WeaviateClass.VectorConfig.builder() - .vectorIndexType("flat") - .vectorizer(text2vecContextionary) - .vectorIndexConfig(VectorIndexConfig.builder() - .bq(BQConfig.builder().enabled(true).build()) - .build()) - .build()); - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(properties) - .vectorConfig(vectorConfig) - .build(); - // Supply - Result createResult = classCreate.apply(weaviateClass); - assertThat(createResult).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - - // create object - String id = "00000000-0000-0000-0000-000000000001"; - Map props = new HashMap<>(); - props.put("name", "some name"); - props.put("title", "The Lord of the Rings"); - Float[] vector = new Float[] { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }; - Map vectors = new HashMap<>(); - vectors.put("hnswVector", vector); - WeaviateObject obj = WeaviateObject.builder() - .id(id) - .className(className) - .properties(props) - .vectors(vectors) - .build(); - Result result = batchCreate.apply(obj); - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(1); - - // fetch that object - Result> resultObj = fetch.apply(obj); - assertThat(resultObj).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(r -> r.get(0)).isNotNull() - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(obj.getId()); - assertThat(o.getVectors()).isNotEmpty() - .containsOnlyKeys("hnswVector", "c11y") - .satisfies(vecs -> { - assertThat(vecs.get("hnswVector")).isNotNull().isEqualTo(vector); - assertThat(vecs.get("c11y")).isNotEmpty(); - }); - assertThat(o.getProperties()).isNotNull() - .extracting(Map::size).isEqualTo(obj.getProperties().size()); - obj.getProperties().keySet().forEach(propName -> { - assertThat(o.getProperties().get(propName)).isNotNull(); - }); - }); - - // clean up - Result delete = deleteClass.apply(className); - assertThat(delete).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } - - public static void shouldCreateObjectsWithNamedMultiVectors(Function> classCreate, - Function> batchCreate, - Function>> fetch, - Function> deleteClass) { - - // Arrange: Configure collection and create it - String className = "NamedMultiVectors"; - WeaviateClass weaviateClass = WeaviateClass.builder() - .className(className) - .properties(Arrays.asList( - Property.builder() - .name("name") - .dataType(Collections.singletonList(DataType.TEXT)) - .build(), - Property.builder() - .name("title") - .dataType(Collections.singletonList(DataType.TEXT)) - .build())) - .vectorConfig(new HashMap() { - { - this.put("regular", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }) - .vectorIndexType("hnsw") - .build()); - this.put("colbert", WeaviateClass.VectorConfig.builder() - .vectorizer(new HashMap() { - { - this.put("none", new Object()); - } - }) - .vectorIndexConfig(VectorIndexConfig.builder() - .multiVector(MultiVectorConfig.builder().build()) - .build()) - .vectorIndexType("hnsw") - .build()); - } - }) - .build(); - - Result createResult = classCreate.apply(weaviateClass); - assertThat(createResult).isNotNull() - .returns(null, Result::getError).as("create class error") - .returns(true, Result::getResult).as("create class successful"); - - // Arrange: Prepare test object - String id = UUID.randomUUID().toString(); - Float[][] colbertVector = new Float[][] { - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - { 0.11f, 0.22f, 0.33f, 0.123f, -0.900009f, -0.0000000001f }, - }; - WeaviateObject testObject = WeaviateObject.builder() - .id(id).className(className) - .properties(new HashMap() { - { - this.put("name", "TestObject-1"); - this.put("title", "The Lord of the Rings"); - } - }) - .vectors(new HashMap() { - { - this.put("regular", colbertVector[0]); - } - }) - .multiVectors(new HashMap() { - { - this.put("colbert", colbertVector); - } - }) - .build(); - - // Act: Run batch insert - Result result = batchCreate.apply(testObject); - assertThat(result).isNotNull() - .returns(null, Result::getError).as("batch insert error") - .extracting(Result::getResult).asInstanceOf(ARRAY) - .hasSize(1) - .satisfies(obj -> { - ObjectGetResponse response = ((ObjectGetResponse) obj[0]); - - assertThat(response).extracting(ObjectGetResponse::getResult) - .satisfies(r -> { - assertThat(r).extracting(ObjectsGetResponseAO2Result::getStatus) - .isEqualTo("SUCCESS").as("gRPC response status"); - assertThat(r).extracting(ObjectsGetResponseAO2Result::getErrors) - .as("gRPC errors").isNull(); - }); - assertThat(response.getMultiVectors()).containsKey("colbert"); - }); - - // Assert: Retrieve object and check its dimensions - Result> resultObj = fetch.apply(testObject); - assertThat(resultObj).isNotNull() - .returns(null, Result::getError).as("fetch object error") - .extracting(Result::getResult).isNotNull().as("result not null") - .extracting(r -> r.get(0)).isNotNull().as("first object") - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(id).as("ids match"); - - // 1d vectors under "vectors" - assertThat(o.getVectors()).isNotEmpty() - .containsOnlyKeys("regular"); - - // ColBERT vectors under "multiVectors" - assertThat(o.getMultiVectors()).isNotEmpty() - .containsOnlyKeys("colbert") - .satisfies(vecs -> { - assertThat(vecs.get("colbert")).isEqualTo(colbertVector) - .as("colbert vector"); - }).as("has expected vectors"); - - assertThat(o.getProperties()).isNotNull() - .extracting(Map::size).isEqualTo(testObject.getProperties().size()) - .as("has expected properties"); - - testObject.getProperties().keySet().forEach(propName -> { - assertThat(o.getProperties().get(propName)) - .isNotNull().as(propName); - }); - }).as("expected object metadata"); - - // clean up - Result delete = deleteClass.apply(className); - assertThat(delete).isNotNull() - .returns(false, Result::hasErrors) - .returns(true, Result::getResult); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateTestSuite.java b/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateTestSuite.java deleted file mode 100644 index 02f418703..000000000 --- a/src/test/java/io/weaviate/integration/tests/batch/ClientBatchGrpcCreateTestSuite.java +++ /dev/null @@ -1,208 +0,0 @@ -package io.weaviate.integration.tests.batch; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.misc.model.BQConfig; -import io.weaviate.client.v1.misc.model.SQConfig; -import io.weaviate.client.v1.misc.model.RQConfig; -import io.weaviate.client.v1.misc.model.VectorIndexConfig; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateTestGenerics; -import java.util.List; -import java.util.Map; -import java.util.function.Function; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; -import org.junit.platform.commons.util.StringUtils; - -public class ClientBatchGrpcCreateTestSuite { - - public static void shouldCreateBatch(WeaviateClient client, - Function> createClass, - Function> batchCreate, - Function>> fetchObject, - Function> deleteClass) { - - testSuite t = new testSuite(client, createClass, batchCreate, fetchObject, deleteClass); - - t.testCreateBatch(); - t.testCreateBatchWithNested(); - t.testCreateBatchWithNestedAndNestArrayObject(); - t.testCreateBatchWithReferenceWithoutNested(); - t.testCreateBatchWithMultiReferenceWithoutNested(); - t.testCreateBatchWithReferenceWithNested(); - t.testCreateBatchWithMultiReferenceWithNested(); - t.testCreateBatchWithFlatVectorIndex(); - t.testCreateBatchWithHNSWSQVectorIndex(); - t.testCreateBatchWithHNSWRQVectorIndex(); - } - - private static class testSuite { - - private final WeaviateClient client; - private final Function> createClass; - private final Function> batchCreate; - private final Function>> fetchObject; - private final Function> deleteClass; - - public testSuite(WeaviateClient client, Function> createClass, - Function> batchCreate, - Function>> fetchObject, - Function> deleteClass) { - this.client = client; - this.createClass = createClass; - this.batchCreate = batchCreate; - this.fetchObject = fetchObject; - this.deleteClass = deleteClass; - } - - public void testCreateBatchWithReferenceWithoutNested() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - // create ref class and populate objects - testData.createRefClassesWithObjects(client); - // create all properties class - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithCrossReference(); - WeaviateObject[] objects = testData.objectsWithCrossReferences(); - testCreateBatch(className, properties, objects); - // delete ref class - testData.deleteRefClasses(client); - } - - public void testCreateBatchWithMultiReferenceWithoutNested() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - // create ref class and populate objects - testData.createRefClassesWithObjects(client); - // create all properties class - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithMultiCrossReference(); - WeaviateObject[] objects = testData.objectsWithMultiCrossReferences(); - testCreateBatch(className, properties, objects); - // delete ref class - testData.deleteRefClasses(client); - } - - public void testCreateBatchWithReferenceWithNested() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - // create ref class and populate objects - testData.createRefClassesWithObjects(client); - // create all properties class - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithCrossReferenceWithNestedProperties(); - WeaviateObject[] objects = testData.objectsWithCrossReferencesWithNestedProperties(); - testCreateBatch(className, properties, objects); - // delete ref class - testData.deleteRefClasses(client); - } - - public void testCreateBatchWithMultiReferenceWithNested() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - // create ref class and populate objects - testData.createRefClassesWithObjects(client); - // create all properties class - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithMultiCrossReferenceWithNestedProperties(); - WeaviateObject[] objects = testData.objectsWithMultiCrossReferencesWithNestedProperties(); - testCreateBatch(className, properties, objects); - // delete ref class - testData.deleteRefClasses(client); - } - - public void testCreateBatch(String vectorIndexType, VectorIndexConfig vectorIndexConfig) { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - String className = testData.CLASS_NAME; - List properties = testData.properties(); - WeaviateObject[] objects = testData.objects(); - testCreateBatch(className, properties, objects, vectorIndexType, vectorIndexConfig); - } - - public void testCreateBatchWithFlatVectorIndex() { - VectorIndexConfig vectorIndexConfig = - VectorIndexConfig.builder().bq(BQConfig.builder().enabled(true).build()).build(); - testCreateBatch("flat", vectorIndexConfig); - } - - public void testCreateBatchWithHNSWSQVectorIndex() { - VectorIndexConfig vectorIndexConfig = - VectorIndexConfig.builder().sq(SQConfig.builder().enabled(true).build()).build(); - testCreateBatch("hnsw", vectorIndexConfig); - } - - public void testCreateBatchWithHNSWRQVectorIndex() { - VectorIndexConfig vectorIndexConfig = - VectorIndexConfig.builder().rq(RQConfig.builder().enabled(true).build()).build(); - testCreateBatch("hnsw", vectorIndexConfig); - } - - public void testCreateBatch() { - testCreateBatch(null, null); - } - - public void testCreateBatchWithNested() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithNestedObject(); - WeaviateObject[] objects = testData.objectsWithNestedObject(); - testCreateBatch(className, properties, objects); - } - - public void testCreateBatchWithNestedAndNestArrayObject() { - WeaviateTestGenerics.AllPropertiesSchema testData = - new WeaviateTestGenerics.AllPropertiesSchema(); - String className = testData.CLASS_NAME; - List properties = testData.propertiesWithNestedObjectAndNestedArrayObject(); - WeaviateObject[] objects = testData.objectsWithNestedObjectAndNestedArrayObject(); - testCreateBatch(className, properties, objects); - } - - public void testCreateBatch(String className, List properties, - WeaviateObject[] objects) { - testCreateBatch(className, properties, objects, null, null); - } - - public void testCreateBatch(String className, List properties, - WeaviateObject[] objects, String vectorIndexType, VectorIndexConfig vectorIndexConfig) { - // create schema - WeaviateClass.WeaviateClassBuilder weaviateClassBuilder = - WeaviateClass.builder().className(className).properties(properties); - if (StringUtils.isNotBlank(vectorIndexType) && vectorIndexConfig != null) { - weaviateClassBuilder.vectorIndexType(vectorIndexType).vectorIndexConfig(vectorIndexConfig); - } - Result createResult = this.createClass.apply(weaviateClassBuilder.build()); - assertThat(createResult).isNotNull().returns(false, Result::hasErrors).returns(true, - Result::getResult); - - Result result = this.batchCreate.apply(objects); - assertThat(result).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .asInstanceOf(ARRAY).hasSize(objects.length); - - for (WeaviateObject obj : objects) { - Result> resultObj = fetchObject.apply(obj); - assertThat(resultObj).isNotNull().returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull().extracting(r -> r.get(0)).isNotNull() - .satisfies(o -> { - assertThat(o.getId()).isEqualTo(obj.getId()); - assertThat(o.getVector()).isNotEmpty(); - assertThat(o.getProperties()).isNotNull().extracting(Map::size) - .isEqualTo(obj.getProperties().size()); - obj.getProperties().keySet().forEach(propName -> { - assertThat(o.getProperties().get(propName)).isNotNull(); - }); - }); - } - // clean up - Result delete = this.deleteClass.apply(className); - assertThat(delete).isNotNull().returns(false, Result::hasErrors).extracting(Result::getResult) - .isEqualTo(Boolean.TRUE); - } - } -} diff --git a/src/test/java/io/weaviate/integration/tests/classifications/ClassificationsTestSuite.java b/src/test/java/io/weaviate/integration/tests/classifications/ClassificationsTestSuite.java deleted file mode 100644 index f3caa99ad..000000000 --- a/src/test/java/io/weaviate/integration/tests/classifications/ClassificationsTestSuite.java +++ /dev/null @@ -1,131 +0,0 @@ -package io.weaviate.integration.tests.classifications; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.batch.model.ObjectGetResponse; -import io.weaviate.client.v1.classifications.model.Classification; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import io.weaviate.integration.client.WeaviateTestGenerics; -import org.junit.Assert; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -public class ClassificationsTestSuite { - - public static void testScheduler(Supplier> supplier, - Supplier> supplierComplete, - WeaviateTestGenerics testGenerics, - WeaviateClient client) { - - // given - createClassificationClasses(client, testGenerics); - - // when - Result classification = supplier.get(); - Result classificationWithComplete = supplierComplete.get(); - - // then - assertNotNull(classification); - assertNotNull(classification.getResult()); - assertTrue(Arrays.asList(classification.getResult().getBasedOnProperties()).contains("description")); - assertTrue(Arrays.asList(classification.getResult().getClassifyProperties()).contains("tagged")); - assertEquals("running", classification.getResult().getStatus()); - assertNotNull(classificationWithComplete); - assertNotNull(classificationWithComplete.getResult()); - assertTrue(Arrays.asList(classificationWithComplete.getResult().getBasedOnProperties()).contains("description")); - assertTrue(Arrays.asList(classificationWithComplete.getResult().getClassifyProperties()).contains("tagged")); - assertNotEquals("running", classificationWithComplete.getResult().getStatus()); - } - - public static void testGetter(Supplier> supplierScheduler, - Function> supplierGetter, - WeaviateTestGenerics testGenerics, - WeaviateClient client) { - // given - createClassificationClasses(client, testGenerics); - - // when - Result classification = supplierScheduler.get(); - Result knnClassification = supplierGetter.apply(classification.getResult().getId()); - - // then - assertNotNull(classification); - assertNotNull(classification.getResult()); - assertNotNull(knnClassification); - assertNotNull(knnClassification.getResult()); - assertEquals(classification.getResult().getId(), knnClassification.getResult().getId()); - assertTrue(knnClassification.getResult().getSettings() instanceof Map); - Map settings = (Map) knnClassification.getResult().getSettings(); - assertEquals(3.0, settings.get("k")); - } - - - private static void createClassificationClasses(WeaviateClient client, WeaviateTestGenerics testGenerics) { - testGenerics.createWeaviateTestSchemaFood(client); - // define Tag class - Property nameProperty = Property.builder() - .dataType(Arrays.asList(DataType.TEXT)) - .description("name") - .name("name") - .build(); - WeaviateClass schemaClassTag = WeaviateClass.builder() - .className("Tag") - .description("tag for a pizza") - .properties(Stream.of(nameProperty).collect(Collectors.toList())) - .build(); - Result classCreate = client.schema().classCreator().withClass(schemaClassTag).run(); - assertNotNull(classCreate); - assertTrue(classCreate.getResult()); - // add tagged property - Property tagProperty = Property.builder() - .dataType(Arrays.asList("Tag")) - .description("tag of pizza") - .name("tagged") - .build(); - Result addTaggedProperty = client.schema().propertyCreator().withProperty(tagProperty).withClassName("Pizza").run(); - assertNotNull(addTaggedProperty); - assertTrue(addTaggedProperty.getResult()); - // create 2 pizzas - String pizza1ID = "97fa5147-bdad-4d74-9a81-f8babc811b09"; - WeaviateObject pizza1 = WeaviateObject.builder().className("Pizza").id(pizza1ID).properties(new HashMap() {{ - put("name", "Quattro Formaggi"); - put("description", "Pizza quattro formaggi Italian: [ˈkwattro forˈmaddʒi] (four cheese pizza) is a variety of pizza in Italian cuisine that is topped " + - "with a combination of four kinds of cheese, usually melted together, with (rossa, red) or without (bianca, white) tomato sauce. It is popular " + - "worldwide, including in Italy,[1] and is one of the iconic items from pizzerias's menus."); - }}).build(); - String pizza2ID = "97fa5147-bdad-4d74-9a81-f8babc811b19"; - WeaviateObject pizza2 = WeaviateObject.builder().className("Pizza").id(pizza2ID).properties(new HashMap() {{ - put("name", "Frutti di Mare"); - put("description", "Frutti di Mare is an Italian type of pizza that may be served with scampi, mussels or squid. It typically lacks cheese, with the seafood being served atop a tomato sauce."); - }}).build(); - Result batchImport = client.batch().objectsBatcher().withObjects(pizza1, pizza2).run(); - assertNotNull(batchImport); - assertNotNull(batchImport.getResult()); - Assert.assertEquals(2, batchImport.getResult().length); - // create 2 tags - WeaviateObject tag1 = WeaviateObject.builder().className("Tag").properties(new HashMap() {{ - put("name", "vegetarian"); - }}).build(); - WeaviateObject tag2 = WeaviateObject.builder().className("Tag").properties(new HashMap() {{ - put("name", "seafood"); - }}).build(); - Result batchImport2 = client.batch().objectsBatcher().withObjects(tag1, tag2).run(); - assertNotNull(batchImport2); - assertNotNull(batchImport2.getResult()); - Assert.assertEquals(2, batchImport2.getResult().length); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/cluster/ClusterMultiTenancyTestSuite.java b/src/test/java/io/weaviate/integration/tests/cluster/ClusterMultiTenancyTestSuite.java deleted file mode 100644 index 48df29c82..000000000 --- a/src/test/java/io/weaviate/integration/tests/cluster/ClusterMultiTenancyTestSuite.java +++ /dev/null @@ -1,92 +0,0 @@ -package io.weaviate.integration.tests.cluster; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.TriConsumer; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.client.v1.schema.model.Tenant; -import io.weaviate.integration.client.WeaviateTestGenerics; - -import java.util.Arrays; -import java.util.List; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_GIT_HASH; -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -public class ClusterMultiTenancyTestSuite { - - public static void testMultiTenancyDataPerClassOutputVerbose(Supplier> supplierAll, - Supplier> supplierPizza, - Supplier> supplierSoup, - WeaviateTestGenerics testGenerics, - WeaviateClient client) throws InterruptedException { - // given - Tenant[] pizzaTenants = new Tenant[] { - Tenant.builder().name("TenantPizza1").build(), - Tenant.builder().name("TenantPizza2").build(), - }; - Tenant[] soupTenants = new Tenant[] { - Tenant.builder().name("TenantSoup1").build(), - Tenant.builder().name("TenantSoup2").build(), - Tenant.builder().name("TenantSoup3").build(), - }; - String[] pizzaTenantNames = Arrays.stream(pizzaTenants).map(Tenant::getName).toArray(String[]::new); - String[] soupTenantNames = Arrays.stream(soupTenants).map(Tenant::getName).toArray(String[]::new); - - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - testGenerics.createSchemaPizzaForTenants(client); - testGenerics.createTenantsPizza(client, pizzaTenants); - testGenerics.createDataPizzaForTenants(client, pizzaTenantNames); - testGenerics.createSchemaSoupForTenants(client); - testGenerics.createTenantsSoup(client, soupTenants); - testGenerics.createDataSoupForTenants(client, soupTenantNames); - Thread.sleep(3000); // makes sure data are flushed so nodes endpoint returns actual object/shard count - - Consumer> assertSingleNode = (Result result) -> - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(NodesStatusResponse::getNodes).asInstanceOf(ARRAY) - .hasSize(1); - - TriConsumer assertCounts = (NodesStatusResponse.NodeStatus nodeStatus, Long shardCount, Long objectCount) -> { - assertThat(nodeStatus.getName()).isNotBlank(); - assertThat(nodeStatus) - .returns(EXPECTED_WEAVIATE_VERSION, NodesStatusResponse.NodeStatus::getVersion) - .returns(EXPECTED_WEAVIATE_GIT_HASH, NodesStatusResponse.NodeStatus::getGitHash) - .returns(NodesStatusResponse.Status.HEALTHY, NodesStatusResponse.NodeStatus::getStatus) - .extracting(NodesStatusResponse.NodeStatus::getStats) - .returns(shardCount, NodesStatusResponse.Stats::getShardCount) - .returns(objectCount, NodesStatusResponse.Stats::getObjectCount); - }; - - // ALL - Result resultAll = supplierAll.get(); - - long expectedAllShardCount = pizzaTenants.length + soupTenants.length; - long expectedAllObjectsCount = pizzaTenants.length * pizzaIds.size() + soupTenants.length * soupIds.size(); - assertSingleNode.accept(resultAll); - assertCounts.accept(resultAll.getResult().getNodes()[0], expectedAllShardCount, expectedAllObjectsCount); - - // PIZZA - Result resultPizza = supplierPizza.get(); - - long expectedPizzaShardCount = pizzaTenants.length; - long expectedPizzaObjectsCount = pizzaTenants.length * pizzaIds.size(); - assertSingleNode.accept(resultPizza); - assertCounts.accept(resultPizza.getResult().getNodes()[0], expectedPizzaShardCount, expectedPizzaObjectsCount); - - // SOUP - Result resultSoup = supplierSoup.get(); - - long expectedSoupShardCount = soupTenants.length; - long expectedSoupObjectsCount = soupTenants.length * soupIds.size(); - assertSingleNode.accept(resultSoup); - assertCounts.accept(resultSoup.getResult().getNodes()[0], expectedSoupShardCount, expectedSoupObjectsCount); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/cluster/ClusterTestSuite.java b/src/test/java/io/weaviate/integration/tests/cluster/ClusterTestSuite.java deleted file mode 100644 index a43b771b7..000000000 --- a/src/test/java/io/weaviate/integration/tests/cluster/ClusterTestSuite.java +++ /dev/null @@ -1,161 +0,0 @@ -package io.weaviate.integration.tests.cluster; - -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.util.TriConsumer; -import io.weaviate.client.v1.cluster.model.NodesStatusResponse; -import io.weaviate.integration.client.WeaviateTestGenerics; - -import java.util.List; -import java.util.function.Consumer; -import java.util.function.Supplier; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_GIT_HASH; -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.InstanceOfAssertFactories.ARRAY; - -public class ClusterTestSuite { - - public static void testNoDataOutputVerbose(Supplier> supplier) { - // when - Result result = supplier.get(); - - // then - assertThat(result).isNotNull(); - assertThat(result.hasErrors()).isFalse(); - - NodesStatusResponse nodes = result.getResult(); - assertThat(nodes).isNotNull(); - assertThat(nodes.getNodes()).hasSize(1); - - NodesStatusResponse.NodeStatus nodeStatus = nodes.getNodes()[0]; - assertThat(nodeStatus.getName()).isNotBlank(); - assertThat(nodeStatus.getShards()).isNull(); - assertThat(nodeStatus) - .returns(EXPECTED_WEAVIATE_VERSION, NodesStatusResponse.NodeStatus::getVersion) - .returns(EXPECTED_WEAVIATE_GIT_HASH, NodesStatusResponse.NodeStatus::getGitHash) - .returns(NodesStatusResponse.Status.HEALTHY, NodesStatusResponse.NodeStatus::getStatus) - .extracting(NodesStatusResponse.NodeStatus::getStats) - .returns(0L, NodesStatusResponse.Stats::getShardCount) - .returns(0L, NodesStatusResponse.Stats::getObjectCount); - } - - public static void testDataOutputVerbose(Supplier> supplier, - WeaviateTestGenerics testGenerics, - WeaviateClient client) throws InterruptedException { - // given - testGenerics.createTestSchemaAndData(client); - Thread.sleep(3000); // makes sure data are flushed so nodes endpoint returns actual object/shard count - - // when - Result result = supplier.get(); - - // then - assertThat(result).isNotNull(); - assertThat(result.hasErrors()).isFalse(); - - NodesStatusResponse nodes = result.getResult(); - assertThat(nodes).isNotNull(); - assertThat(nodes.getNodes()).hasSize(1); - - NodesStatusResponse.NodeStatus nodeStatus = nodes.getNodes()[0]; - assertThat(nodeStatus.getName()).isNotBlank(); - assertThat(nodeStatus) - .returns(EXPECTED_WEAVIATE_VERSION, NodesStatusResponse.NodeStatus::getVersion) - .returns(EXPECTED_WEAVIATE_GIT_HASH, NodesStatusResponse.NodeStatus::getGitHash) - .returns(NodesStatusResponse.Status.HEALTHY, NodesStatusResponse.NodeStatus::getStatus) - .extracting(NodesStatusResponse.NodeStatus::getStats) - .returns(2L, NodesStatusResponse.Stats::getShardCount) - .returns(6L, NodesStatusResponse.Stats::getObjectCount); - - assertThat(nodeStatus.getShards()).hasSize(2) - .extracting(NodesStatusResponse.ShardStatus::getClassName) - .containsExactlyInAnyOrder("Pizza", "Soup"); - - for (NodesStatusResponse.ShardStatus shardStatus : nodeStatus.getShards()) { - assertThat(shardStatus.getName()).isNotBlank(); - switch (shardStatus.getClassName()) { - case "Pizza": - assertThat(shardStatus.getObjectCount()).isEqualTo(4L); - break; - case "Soup": - assertThat(shardStatus.getObjectCount()).isEqualTo(2L); - break; - } - } - } - - public static void testDataPerClassOutputVerbose(Supplier> supplierAll, - Supplier> supplierPizza, - Supplier> supplierSoup, - WeaviateTestGenerics testGenerics, - WeaviateClient client) throws InterruptedException { - // given - List pizzaIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Pizza"); - List soupIds = WeaviateTestGenerics.IDS_BY_CLASS.get("Soup"); - testGenerics.createSchemaPizza(client); - testGenerics.createDataPizza(client); - testGenerics.createSchemaSoup(client); - testGenerics.createDataSoup(client); - Thread.sleep(3000); // makes sure data are flushed so nodes endpoint returns actual object/shard count - - Consumer> assertSingleNode = (Result result) -> - assertThat(result).isNotNull() - .returns(false, Result::hasErrors) - .extracting(Result::getResult).isNotNull() - .extracting(NodesStatusResponse::getNodes).asInstanceOf(ARRAY) - .hasSize(1); - - TriConsumer assertCounts = (NodesStatusResponse.NodeStatus nodeStatus, Long shardCount, Long objectCount) -> { - assertThat(nodeStatus.getName()).isNotBlank(); - assertThat(nodeStatus) - .returns(EXPECTED_WEAVIATE_VERSION, NodesStatusResponse.NodeStatus::getVersion) - .returns(EXPECTED_WEAVIATE_GIT_HASH, NodesStatusResponse.NodeStatus::getGitHash) - .returns(NodesStatusResponse.Status.HEALTHY, NodesStatusResponse.NodeStatus::getStatus) - .extracting(NodesStatusResponse.NodeStatus::getStats) - .returns(shardCount, NodesStatusResponse.Stats::getShardCount) - .returns(objectCount, NodesStatusResponse.Stats::getObjectCount); - }; - - // ALL - Result resultAll = supplierAll.get(); - - assertSingleNode.accept(resultAll); - assertCounts.accept(resultAll.getResult().getNodes()[0], 2L, (long) (pizzaIds.size() + soupIds.size())); - - // PIZZA - Result resultPizza = supplierPizza.get(); - - assertSingleNode.accept(resultPizza); - assertCounts.accept(resultPizza.getResult().getNodes()[0], 1L, (long) pizzaIds.size()); - - // SOUP - Result resultSoup = supplierSoup.get(); - - assertSingleNode.accept(resultSoup); - assertCounts.accept(resultSoup.getResult().getNodes()[0], 1L, (long) soupIds.size()); - } - - public static void testNoDataOutputMinimalImplicit(Supplier> supplier) { - // when - Result result = supplier.get(); - - // then - assertThat(result).isNotNull(); - assertThat(result.hasErrors()).isFalse(); - - NodesStatusResponse nodes = result.getResult(); - assertThat(nodes).isNotNull(); - assertThat(nodes.getNodes()).hasSize(1); - - NodesStatusResponse.NodeStatus nodeStatus = nodes.getNodes()[0]; - assertThat(nodeStatus.getName()).isNotBlank(); - assertThat(nodeStatus) - .returns(EXPECTED_WEAVIATE_VERSION, NodesStatusResponse.NodeStatus::getVersion) - .returns(EXPECTED_WEAVIATE_GIT_HASH, NodesStatusResponse.NodeStatus::getGitHash) - .returns(NodesStatusResponse.Status.HEALTHY, NodesStatusResponse.NodeStatus::getStatus) - .returns(null, NodesStatusResponse.NodeStatus::getStats) - .returns(null, NodesStatusResponse.NodeStatus::getShards); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/data/DataTestSuite.java b/src/test/java/io/weaviate/integration/tests/data/DataTestSuite.java deleted file mode 100644 index 5d31648b3..000000000 --- a/src/test/java/io/weaviate/integration/tests/data/DataTestSuite.java +++ /dev/null @@ -1,569 +0,0 @@ -package io.weaviate.integration.tests.data; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.data.model.WeaviateObject; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; - -public class DataTestSuite { - public static class testDataCreate { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result> objectsT, Result> objectsA) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(2, objectsT.getResult().get(0).getProperties().size()); - assertEquals("Pizza", objectsT.getResult().get(0).getClassName()); - assertEquals("Hawaii", objectsT.getResult().get(0).getProperties().get("name")); - assertNotNull(objectsA); - assertNotNull(objectsA.getResult()); - assertEquals(1, objectsA.getResult().size()); - assertEquals(objAID, objectsA.getResult().get(0).getId()); - assertNotNull(objectsA.getResult().get(0).getProperties()); - assertEquals(2, objectsA.getResult().get(0).getProperties().size()); - assertEquals("Soup", objectsA.getResult().get(0).getClassName()); - assertEquals("ChickenSoup", objectsA.getResult().get(0).getProperties().get("name")); - } - } - - public static class testDataCreateWithSpecialCharacters { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String name = "Zażółć gęślą jaźń"; - public static String description = "test äüëö"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", name); - propertiesSchemaT.put("description", description); - return propertiesSchemaT; - } - public static void assertResults(Result objectT, Result> objectsT) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(2, objectsT.getResult().get(0).getProperties().size()); - assertEquals("Pizza", objectsT.getResult().get(0).getClassName()); - assertEquals(name, objectsT.getResult().get(0).getProperties().get("name")); - assertEquals(description, objectsT.getResult().get(0).getProperties().get("description")); - } - } - - public static class testDataGetActionsThings { - public static void assertResults(Result pizzaObj1, Result pizzaObj2, Result soupObj1, - Result soupObj2, Result> objects, Result> afterFirstPizzaObjects) { - assertCreated(pizzaObj1); - assertCreated(pizzaObj2); - assertCreated(soupObj1); - assertCreated(soupObj2); - assertNotNull(objects); - assertNotNull(objects.getResult()); - assertEquals(4, objects.getResult().size()); - assertNull(afterFirstPizzaObjects.getError()); - assertEquals(1l, afterFirstPizzaObjects.getResult().size()); - } - } - - public static class testDataGetWithAdditional { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result> objectsT, Result> objectsA, - Result> objsAdditionalT, Result> objsAdditionalA, Result> objsAdditionalA1, Result> objsAdditionalA2, - Result> objsAdditionalAError) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertNull(objectsT.getResult().get(0).getAdditional()); - assertNotNull(objectsA); - assertNotNull(objectsA.getResult()); - assertEquals(1, objectsA.getResult().size()); - assertNull(objectsA.getResult().get(0).getAdditional()); - assertNotNull(objsAdditionalT); - assertNotNull(objsAdditionalT.getResult()); - assertEquals(1, objsAdditionalT.getResult().size()); - assertNotNull(objsAdditionalT.getResult().get(0).getAdditional()); - assertEquals(2, objsAdditionalT.getResult().get(0).getAdditional().size()); - assertNull(objsAdditionalT.getResult().get(0).getAdditional().get("classification")); - assertNotNull(objsAdditionalT.getResult().get(0).getAdditional().get("nearestNeighbors")); - assertNotNull(objsAdditionalT.getResult().get(0).getVector()); - assertNotNull(objsAdditionalA); - assertNotNull(objsAdditionalA.getResult()); - assertEquals(1, objsAdditionalA.getResult().size()); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional()); - assertEquals(3, objsAdditionalA.getResult().get(0).getAdditional().size()); - assertNull(objsAdditionalA.getResult().get(0).getAdditional().get("classification")); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional().get("nearestNeighbors")); - assertNotNull(objsAdditionalA.getResult().get(0).getAdditional().get("interpretation")); - assertNotNull(objsAdditionalA.getResult().get(0).getVector()); - assertNotNull(objsAdditionalA1.getResult()); - assertEquals(1, objsAdditionalA1.getResult().size()); - assertNull(objsAdditionalA1.getResult().get(0).getAdditional()); - assertNotNull(objsAdditionalA2.getResult()); - assertEquals(1, objsAdditionalA2.getResult().size()); - assertNotNull(objsAdditionalA2.getResult().get(0).getAdditional()); - assertEquals(1, objsAdditionalA2.getResult().get(0).getAdditional().size()); - assertNotNull(objsAdditionalA2.getResult().get(0).getAdditional().get("interpretation")); - assertNotNull(objsAdditionalAError); - assertNull(objsAdditionalAError.getResult()); - } - } - - public static class testDataDelete { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result deleteObjT, Result> objTlist, - Result deleteObjA, Result> objAlist) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(deleteObjT); - assertTrue(deleteObjT.getResult()); - assertNotNull(objTlist); - assertNull(objTlist.getResult()); - assertNotNull(deleteObjA); - assertTrue(deleteObjA.getResult()); - assertNotNull(objAlist); - assertNull(objAlist.getResult()); - } - } - - public static class testDataUpdate { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Random"); - propertiesSchemaT.put("description", "Missing description"); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "water"); - propertiesSchemaA.put("description", "missing description"); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result updateObjectT, - Result updateObjectA, Result> updatedObjsT, Result> updatedObjsA) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(updateObjectT); - assertTrue(updateObjectT.getResult()); - assertNotNull(updateObjectA); - assertTrue(updateObjectA.getResult()); - assertNotNull(updatedObjsT); - assertNotNull(updatedObjsT.getResult()); - assertEquals(1, updatedObjsT.getResult().size()); - assertEquals("Hawaii", updatedObjsT.getResult().get(0).getProperties().get("name")); - assertEquals("Universally accepted to be the best pizza ever created.", updatedObjsT.getResult().get(0).getProperties().get("description")); - assertNotNull(updatedObjsA); - assertNotNull(updatedObjsA.getResult()); - assertEquals(1, updatedObjsA.getResult().size()); - assertEquals("ChickenSoup", updatedObjsA.getResult().get(0).getProperties().get("name")); - assertEquals("Used by humans when their inferior genetics are attacked by microscopic organisms.", updatedObjsA.getResult().get(0).getProperties().get( - "description")); - } - } - - public static class testDataMerge { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Missing description"); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "missing description"); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result mergeObjectT, Result mergeObjectA, - Result> mergedObjsT, Result> mergeddObjsA) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(mergeObjectT); - assertTrue(mergeObjectT.getResult()); - assertNotNull(mergeObjectA); - assertTrue(mergeObjectA.getResult()); - assertNotNull(mergedObjsT); - assertNotNull(mergedObjsT.getResult()); - assertEquals(1, mergedObjsT.getResult().size()); - assertEquals("Hawaii", mergedObjsT.getResult().get(0).getProperties().get("name")); - assertEquals("Universally accepted to be the best pizza ever created.", mergedObjsT.getResult().get(0).getProperties().get("description")); - assertNotNull(mergeddObjsA); - assertNotNull(mergeddObjsA.getResult()); - assertEquals(1, mergeddObjsA.getResult().size()); - assertEquals("ChickenSoup", mergeddObjsA.getResult().get(0).getProperties().get("name")); - assertEquals("Used by humans when their inferior genetics are attacked by microscopic organisms.", mergeddObjsA.getResult().get(0).getProperties().get( - "description")); - } - } - - public static class testDataValidate { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result validateObjT, Result validateObjA, Result validateObjT1, Result validateObjA1) { - assertNotNull(validateObjT); - assertTrue(validateObjT.getResult()); - assertNotNull(validateObjA); - assertTrue(validateObjA.getResult()); - assertNotNull(validateObjT1); - assertNotNull(validateObjT1.getError()); - assertEquals("invalid object: no such prop with name 'test' found in class 'Pizza' in the schema." + - " Check your schema files for which properties in this class are available", - validateObjT1.getError().getMessages().get(0).getMessage()); - assertNotNull(validateObjA1); - assertNotNull(validateObjA1.getError()); - assertEquals("invalid object: no such prop with name 'test' found in class 'Pizza' in the schema." + - " Check your schema files for which properties in this class are available", - validateObjA1.getError().getMessages().get(0).getMessage()); - } - } - - public static class testDataGetWithAdditionalError { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result> objsAdditionalT) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertNotNull(objsAdditionalT); - assertNotNull(objsAdditionalT.getError()); - assertNotNull(objsAdditionalT.getError().getMessages()); - assertEquals("get extend: unknown capability: featureProjection", objsAdditionalT.getError().getMessages().get(0).getMessage()); - } - } - - public static class testDataCreateWithArrayType { - public static WeaviateClass clazz = WeaviateClass.builder() - .className("ClassArrays") - .description("Class which properties are all array properties") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("stringArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT_ARRAY); - }}) - .name("textArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.INT_ARRAY); - }}) - .name("intArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.NUMBER_ARRAY); - }}) - .name("numberArray") - .build()); - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.BOOLEAN_ARRAY); - }}) - .name("booleanArray") - .build()); - }}) - .build(); - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("stringArray", new String[]{"a", "b"}); - propertiesSchemaT.put("textArray", new String[]{"c", "d"}); - propertiesSchemaT.put("intArray", new Integer[]{1, 2}); - propertiesSchemaT.put("numberArray", new Float[]{3.3f, 4.4f}); - propertiesSchemaT.put("booleanArray", new Boolean[]{true, false}); - return propertiesSchemaT; - } - public static void assertResults(Result createStatus, Result schemaAfterCreate, Result objectT, - Result> objectsT, Result deleteStatus, Result schemaAfterDelete) { - // then - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().size()); - // data check - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectsT); - assertNotNull(objectsT.getResult()); - assertEquals(1, objectsT.getResult().size()); - assertEquals(objTID, objectsT.getResult().get(0).getId()); - assertNotNull(objectsT.getResult().get(0).getProperties()); - assertEquals(5, objectsT.getResult().get(0).getProperties().size()); - assertEquals("ClassArrays", objectsT.getResult().get(0).getClassName()); - checkArrays(objectsT.getResult().get(0).getProperties().get("stringArray"), 2, "a", "b"); - checkArrays(objectsT.getResult().get(0).getProperties().get("textArray"), 2, "c", "d"); - checkArrays(objectsT.getResult().get(0).getProperties().get("intArray"), 2, 1.0, 2.0); - checkArrays(objectsT.getResult().get(0).getProperties().get("numberArray"), 2, 3.3, 4.4); - checkArrays(objectsT.getResult().get(0).getProperties().get("booleanArray"), 2, true, false); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testDataGetWithVector { - public static WeaviateClass clazz = WeaviateClass.builder() - .className("ClassCustomVector") - .description("Class with custom vector") - .vectorizer("none") - .properties(new ArrayList() {{ - add(Property.builder() - .dataType(new ArrayList() {{ - add(DataType.TEXT); - }}) - .name("foo") - .build()); - }}) - .build(); - public static String objTID = "addfd256-8574-442b-9293-9205193737ee"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("foo", "bar"); - return propertiesSchemaT; - } - public static Float[] vectorObjT = new Float[]{-0.26736435f, -0.112380296f, 0.29648793f, 0.39212644f, 0.0033650293f, -0.07112332f, 0.07513781f, 0.22459874f}; - public static void assertResults(Result createStatus, Result schemaAfterCreate, Result objectT, Result> objT, - Result deleteStatus, Result schemaAfterDelete) { - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().size()); - // check the object - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertNotNull(objT); - assertNull(objT.getError()); - assertNotNull(objT.getResult()); - assertEquals(objT.getResult().size(), 1); - assertArrayEquals(objT.getResult().get(0).getVector(), vectorObjT); - // clean up - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testObjectCheck { - public static String objTID = "abefd256-8574-442b-9293-9205193737ee"; - public static String objAID = "565da3b6-60b3-40e5-ba21-e6bfe5dbba91"; - public static String nonExistentObjectID = "11111111-1111-1111-aaaa-aaaaaaaaaaaa"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "Hawaii"); - propertiesSchemaT.put("description", "Universally accepted to be the best pizza ever created."); - return propertiesSchemaT; - } - public static Map propertiesSchemaA() { - Map propertiesSchemaA = new HashMap<>(); - propertiesSchemaA.put("name", "ChickenSoup"); - propertiesSchemaA.put("description", "Used by humans when their inferior genetics are attacked by microscopic organisms."); - return propertiesSchemaA; - } - public static void assertResults(Result objectT, Result objectA, Result checkObjT, Result checkObjA, - Result> objA, Result> objT, Result checkNonexistentObject, Result deleteStatus, - Result checkObjTAfterDelete, Result checkObjAAfterDelete) { - assertNotNull(objectT); - assertNotNull(objectT.getResult()); - assertEquals(objTID, objectT.getResult().getId()); - assertNotNull(objectA); - assertNotNull(objectA.getResult()); - assertEquals(objAID, objectA.getResult().getId()); - assertNotNull(checkObjT); - assertTrue(checkObjT.getResult()); - assertNotNull(checkObjA); - assertTrue(checkObjA.getResult()); - assertNotNull(objA.getResult()); - assertEquals(objA.getResult().size(), 1); - assertEquals(objA.getResult().get(0).getId(), objAID); - assertNotNull(objT.getResult()); - assertEquals(objT.getResult().size(), 1); - assertEquals(objT.getResult().get(0).getId(), objTID); - assertNotNull(checkNonexistentObject); - assertFalse(checkNonexistentObject.getResult()); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertNotNull(checkObjTAfterDelete); - assertFalse(checkObjTAfterDelete.getResult()); - assertNull(checkObjTAfterDelete.getError()); - assertNotNull(checkObjAAfterDelete); - assertFalse(checkObjAAfterDelete.getResult()); - assertNull(checkObjAAfterDelete.getError()); - } - } - - public static class testDataCreateWithIDInNotUUIDFormat { - public static String objID = "TODO_4"; - public static Map propertiesSchemaT() { - Map propertiesSchemaT = new HashMap<>(); - propertiesSchemaT.put("name", "name"); - propertiesSchemaT.put("description", "description"); - return propertiesSchemaT; - } - public static void assertResults(Result objectT, Result> objectsT, Result deleteStatus, Result schemaAfterDelete) { - assertNotNull(objectT); - assertNull(objectT.getResult()); - assertNotNull(objectT.getError()); - assertNotNull(objectT.getError().getMessages()); - assertNotNull(objectT.getError().getMessages().get(0)); - assertEquals(422, objectT.getError().getStatusCode()); - assertEquals("id in body must be of type uuid: \"TODO_4\"", objectT.getError().getMessages().get(0).getMessage()); - assertNotNull(objectsT); - assertNull(objectsT.getResult()); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testDataGetUsingClassParameter { - public static void assertResults(Result pizzaObj1, Result pizzaObj2, Result soupObj1, Result soupObj2, - Result> objects, Result> pizzaObjects, Result> soupObjects) { - assertCreated(pizzaObj1); - assertCreated(pizzaObj2); - assertCreated(soupObj1); - assertCreated(soupObj2); - assertNotNull(objects); - assertNotNull(objects.getResult()); - assertEquals(4, objects.getResult().size()); - assertNotNull(pizzaObjects); - assertNotNull(pizzaObjects.getResult()); - assertEquals(2, pizzaObjects.getResult().size()); - assertNotNull(soupObjects); - assertNotNull(soupObjects.getResult()); - assertEquals(2, soupObjects.getResult().size()); - } - } - - private static void assertCreated(Result obj) { - assertNotNull(obj); - assertNotNull(obj.getResult()); - assertNotNull(obj.getResult().getId()); - } - - private static void checkArrays(Object property, int size, Object... contains) { - assertNotNull(property); - assertEquals(ArrayList.class, property.getClass()); - List l = (List) property; - assertEquals(size, l.size()); - for (Object c : contains) { - assertTrue(l.contains(c)); - } - } -} diff --git a/src/test/java/io/weaviate/integration/tests/graphql/ClientGraphQLTypedTestSuite.java b/src/test/java/io/weaviate/integration/tests/graphql/ClientGraphQLTypedTestSuite.java deleted file mode 100644 index d85d3838e..000000000 --- a/src/test/java/io/weaviate/integration/tests/graphql/ClientGraphQLTypedTestSuite.java +++ /dev/null @@ -1,54 +0,0 @@ -package io.weaviate.integration.tests.graphql; - -import com.google.gson.annotations.SerializedName; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.graphql.model.GraphQLGetBaseObject; -import io.weaviate.client.v1.graphql.model.GraphQLTypedResponse; -import java.util.List; -import java.util.function.Supplier; -import lombok.Getter; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -public class ClientGraphQLTypedTestSuite { - - @Getter - public static class Pizzas { - @SerializedName(value = "Pizza") - List pizzas; - - @Getter - public static class Pizza extends GraphQLGetBaseObject { - String name; - String description; - String bestBefore; - Float price; - } - } - - public static void testGraphQLGet(Supplier>> supplyPizza) { - // given - Result> result = supplyPizza.get(); - // then - assertNotNull(result); - assertFalse(result.hasErrors()); - GraphQLTypedResponse gqlResult = result.getResult(); - assertNotNull(gqlResult); - assertNotNull(gqlResult.getData()); - GraphQLTypedResponse.Operation resp = gqlResult.getData(); - assertNotNull(resp.getObjects()); - assertNotNull(resp.getObjects().getPizzas()); - List pizzas = resp.getObjects().getPizzas(); - assertTrue(pizzas.size() == 4); - String name = pizzas.get(0).getName(); - assertNotNull(name); - assertTrue(name.length() > 0); - String description = pizzas.get(0).getDescription(); - assertNotNull(description); - assertTrue(description.length() > 0); - assertNull(pizzas.get(0).getPrice()); - assertNull(pizzas.get(0).getBestBefore()); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/groups/ClientGroupsTestSuite.java b/src/test/java/io/weaviate/integration/tests/groups/ClientGroupsTestSuite.java deleted file mode 100644 index 7d2f2de33..000000000 --- a/src/test/java/io/weaviate/integration/tests/groups/ClientGroupsTestSuite.java +++ /dev/null @@ -1,155 +0,0 @@ -package io.weaviate.integration.tests.groups; - -import java.util.List; -import java.util.function.Supplier; - -import org.assertj.core.api.Assertions; -import org.assertj.core.api.InstanceOfAssertFactories; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.junit.runner.RunWith; -import org.testcontainers.weaviate.WeaviateContainer; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import com.jparams.junit4.description.Name; - -import io.weaviate.client.Config; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.rbac.model.GroupAssignment; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithRbacContainer; -import io.weaviate.integration.tests.rbac.ClientRbacTestSuite; - -@RunWith(JParamsTestRunner.class) -public class ClientGroupsTestSuite { - - private static final String adminUser = "john-doe"; - private static final String API_KEY = WeaviateWithRbacContainer.makeSecret(adminUser); - - @Rule - public TestName currentTest = new TestName(); - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithRbacContainer( - WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE, - adminUser); - - public static Config config() { - return new Config("http", weaviate.getHttpHostAddress()); - } - - public static Object[][] clients() { - try { - return new Object[][] { - { "sync", - (Supplier) () -> new io.weaviate.integration.client.groups.ClientGroupsTest(config(), API_KEY) }, - { "async", - (Supplier) () -> new io.weaviate.integration.client.async.groups.ClientGroupsTest(config(), - API_KEY) } - }; - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - @DataMethod(source = ClientGroupsTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testAssignGetRevoke(String _kind, Supplier oidcHandle) { - Oidc oidc = oidcHandle.get(); - String groupId = "./assign-group"; - String[] roles = new String[] { "viewer", "admin" }; - - oidc.revokeRoles(groupId, roles); - Assertions.assertThat(oidc.getAssignedRoles(groupId)) - .extracting(Result::getResult, InstanceOfAssertFactories.LIST) - .isEmpty(); - - oidc.assignRoles(groupId, roles); - Assertions.assertThat(oidc.getAssignedRoles(groupId)) - .extracting(Result::getResult, InstanceOfAssertFactories.list(Role.class)) - .extracting(Role::getName).containsOnly(roles); - - oidc.revokeRoles(groupId, roles); - Assertions.assertThat(oidc.getAssignedRoles(groupId).getResult()).isEmpty(); - } - - @DataMethod(source = ClientGroupsTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testGetAllKnownRoleGroups(String _kind, Supplier oidcHandle) { - Oidc oidc = oidcHandle.get(); - String group1 = "./group-1"; - String group2 = "./group-2"; - - oidc.assignRoles(group1, "viewer"); - oidc.assignRoles(group2, "viewer"); - - Assertions.assertThat(oidc.getKnownGroupNames()) - .extracting(Result::getResult, InstanceOfAssertFactories.list(String.class)) - .containsOnly(group1, group2); - - oidc.revokeRoles(group1, "viewer"); - oidc.revokeRoles(group2, "viewer"); - - Assertions.assertThat(oidc.getKnownGroupNames()) - .extracting(Result::getResult, InstanceOfAssertFactories.LIST) - .isEmpty(); - } - - @DataMethod(source = ClientGroupsTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testGetGroupAssignments(String _kind, Supplier oidcHandle) { - Oidc oidc = oidcHandle.get(); - String role = roleName("testGroupAssignmentsRole"); - - oidc.deleteRole(role); - oidc.createRole(role); - - Assertions.assertThat(oidc.getGroupAssignments(role)) - .extracting(Result::getResult, InstanceOfAssertFactories.LIST) - .isEmpty(); - - oidc.assignRoles("./group-1", role); - oidc.assignRoles("./group-2", role); - - Assertions.assertThat(oidc.getGroupAssignments(role)) - .extracting(Result::getResult, InstanceOfAssertFactories.list(GroupAssignment.class)) - .extracting(GroupAssignment::getGroupId) - .containsOnly("./group-1", "./group-2"); - - oidc.revokeRoles("./group-1", role); - oidc.revokeRoles("./group-2", role); - Assertions.assertThat(oidc.getGroupAssignments(role)) - .extracting(Result::getResult, InstanceOfAssertFactories.LIST) - .isEmpty(); - } - - /** Prefix the role with the name of the current test for easier debugging */ - private String roleName(String name) { - return String.format("%s-%s", currentTest.getMethodName(), name); - } - - /** - * Sync and async test suits should provide an implementation of this interface. - * This way the test suite can be written once with very little - * boilerplate/overhead. - * - * Extends {@link ClientRbacTestSuite.Rbac} because many tests require the - * functionality for creating / deleting / verifying roles. - */ - public interface Oidc extends ClientRbacTestSuite.Rbac { - Result> getAssignedRoles(String groupId); - - Result> getKnownGroupNames(); - - Result assignRoles(String groupId, String... roles); - - Result revokeRoles(String groupId, String... roles); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/misc/MiscTestSuite.java b/src/test/java/io/weaviate/integration/tests/misc/MiscTestSuite.java deleted file mode 100644 index 962ccab22..000000000 --- a/src/test/java/io/weaviate/integration/tests/misc/MiscTestSuite.java +++ /dev/null @@ -1,24 +0,0 @@ -package io.weaviate.integration.tests.misc; - -import static io.weaviate.integration.client.WeaviateVersion.EXPECTED_WEAVIATE_VERSION; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.misc.model.Meta; - -public class MiscTestSuite { - public static void assertLivenessOrReadiness(Result result) { - assertNotNull(result); - assertTrue(result.getResult()); - } - - public static void assertMeta(Result meta) { - assertNotNull(meta); - assertNull(meta.getError()); - assertEquals("http://[::]:8080", meta.getResult().getHostname()); - assertEquals(EXPECTED_WEAVIATE_VERSION, meta.getResult().getVersion()); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/rbac/ClientRbacTestSuite.java b/src/test/java/io/weaviate/integration/tests/rbac/ClientRbacTestSuite.java deleted file mode 100644 index 21f3ef771..000000000 --- a/src/test/java/io/weaviate/integration/tests/rbac/ClientRbacTestSuite.java +++ /dev/null @@ -1,344 +0,0 @@ -package io.weaviate.integration.tests.rbac; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.util.Arrays; -import java.util.List; -import java.util.function.Supplier; - -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.junit.runner.RunWith; -import org.testcontainers.weaviate.WeaviateContainer; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import com.jparams.junit4.description.Name; - -import io.weaviate.client.Config; -import io.weaviate.client.base.Result; -import io.weaviate.client.v1.rbac.model.AliasPermission; -import io.weaviate.client.v1.rbac.model.BackupsPermission; -import io.weaviate.client.v1.rbac.model.ClusterPermission; -import io.weaviate.client.v1.rbac.model.CollectionsPermission; -import io.weaviate.client.v1.rbac.model.DataPermission; -import io.weaviate.client.v1.rbac.model.GroupAssignment; -import io.weaviate.client.v1.rbac.model.GroupsPermission; -import io.weaviate.client.v1.rbac.model.NodesPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.ReplicatePermission; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.rbac.model.RolesPermission; -import io.weaviate.client.v1.rbac.model.TenantsPermission; -import io.weaviate.client.v1.rbac.model.UserAssignment; -import io.weaviate.client.v1.rbac.model.UsersPermission; -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithRbacContainer; - -@RunWith(JParamsTestRunner.class) -public class ClientRbacTestSuite { - - private static final String adminRole = "admin"; - private static final String rootRole = "root"; - private static final String viewerRole = "viewer"; - private static final String adminUser = "john-doe"; - private static final String API_KEY = WeaviateWithRbacContainer.makeSecret(adminUser); - - @Rule - public TestName currentTest = new TestName(); - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithRbacContainer( - WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE, - adminUser); - - public static Config config() { - return new Config("http", weaviate.getHttpHostAddress()); - } - - public static Object[][] clients() { - try { - return new Object[][] { - { "sync", - (Supplier) () -> new io.weaviate.integration.client.rbac.ClientRbacTest(config(), API_KEY) }, - { "async", - (Supplier) () -> new io.weaviate.integration.client.async.rbac.ClientRbacTest(config(), API_KEY) } - }; - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * By default the admin user which we use to run the tests - * will have 'admin' and 'viewer' roles. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testGetAll(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - Result> response = roles.getAll(); - List all = response.getResult(); - - assertThat(response.getError()).as("get all roles error").isNull(); - assertThat(all).hasSize(3).as("wrong number of roles"); - assertThat(all.get(0)).returns(adminRole, Role::getName); - assertThat(all.get(1)).returns(rootRole, Role::getName); - assertThat(all.get(2)).returns(viewerRole, Role::getName); - } - - /** Admin user should have the admin role assigned to them. */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testGetAssignedUsers(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - Result> response = roles.getAssignedUsers(rootRole); - assertThat(response.getError()).as("get assigned users error").isNull(); - - List users = response.getResult(); - assertThat(users).as("users assigned to " + rootRole + " role").hasSize(1); - assertEquals(adminUser, users.get(0), "wrong user assinged to " + rootRole + " role"); - } - - /** Admin user should have the admin role assigned to them. */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testGetUserAssignments(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - Result> response = roles.getUserAssignments(rootRole); - assertThat(response.getError()).as("get assigned users error").isNull(); - - List users = response.getResult(); - // If OIDC is enabled, db / db_env users will appear in the list twice: - // once as 'db" and once as an 'oidc' user. - assertThat(users).as("users assignments to " + rootRole + " role").hasSize(2); - assertEquals(adminUser, users.get(0).getUserId(), "wrong user assinged to " + rootRole + " role"); - assertArrayEquals(new String[] { "db_env_user", "oidc" }, - users.stream().map(UserAssignment::getUserType).sorted().toArray()); - } - - /** - * Created role should have all of the permissions it was created with. - * Tests addition and fetching the role to. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testCreate(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - String myRole = roleName("VectorOwner"); - String myCollection = "Pizza"; - String myCollectionAlias = "PizzaAlias"; - String myShard = "shard-123"; - String myGroup = "my-group"; - - Permission[] wantPermissions = new Permission[] { - Permission.alias(myCollectionAlias, myCollection, AliasPermission.Action.CREATE), - Permission.backups(myCollection, BackupsPermission.Action.MANAGE), - Permission.cluster(ClusterPermission.Action.READ), - Permission.nodes(myCollection, NodesPermission.Action.READ), - Permission.roles(viewerRole, RolesPermission.Action.CREATE), - Permission.collections(myCollection, CollectionsPermission.Action.CREATE), - Permission.data(myCollection, DataPermission.Action.UPDATE), - Permission.groups(myGroup, "oidc", GroupsPermission.Action.READ), - Permission.tenants(TenantsPermission.Action.DELETE), - Permission.users(UsersPermission.Action.READ), - Permission.replicate(myCollection, myShard, ReplicatePermission.Action.READ), - }; - - try { - // Arrange - roles.deleteRole(myRole); - - // Act - Result create = roles.createRole(myRole, wantPermissions); - assertNull("error creating role", create.getError()); - assertTrue("created successfully", create.getResult()); - - Result response = roles.getRole(myRole); - Role role = response.getResult(); - assertNull("error fetching a role", response.getError()); - assertThat(role).as("wrong role name").returns(myRole, Role::getName); - - Arrays.stream(wantPermissions).forEach(perm -> { - assertTrue("should have permission " + perm, checkHasPermission(roles, myRole, perm)); - }); - } finally { - roles.deleteRole(myRole); - } - } - - /** - * Role can be extended with new permissions. We do not test the "upsert" - * behavior because it is the server's responsibility. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testAddPermissions(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - String myRole = roleName("VectorOwner"); - Permission toAdd = Permission.cluster(ClusterPermission.Action.READ); - try { - // Arrange - roles.createRole(myRole, Permission.tenants(TenantsPermission.Action.DELETE)); - - // Act - Result response = roles.addPermissions(myRole, toAdd); - assertNull("add-permissions operation error", response.getError()); - - // Assert - assertTrue("should have permission " + toAdd, checkHasPermission(roles, myRole, toAdd)); - } finally { - roles.deleteRole(myRole); - } - } - - /** - * Check query builder accepts arrays of permissions, - * which is handy in combination with factory methods that create permissions - * with multiple actions. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testAddPermissionsMultipleActions(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - String myRole = roleName("VectorOwner"); - Permission toAdd = Permission.data("Pizza", - DataPermission.Action.READ, - DataPermission.Action.CREATE); - try { - // Arrange - roles.createRole(myRole, Permission.collections("Pizza", - CollectionsPermission.Action.UPDATE, - CollectionsPermission.Action.DELETE)); - - // Act - Result response = roles.addPermissions(myRole, toAdd); - assertNull("add-permissions operation error", response.getError()); - - // Assert - assertTrue("should have permission " + toAdd, checkHasPermission(roles, myRole, toAdd)); - } finally - - { - roles.deleteRole(myRole); - } - } - - /** - * Permissions can be removed from a role. - * We do not test the "downsert" behavior, because it is the server's - * responsibility. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testRemovePermissions(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - String myRole = roleName("VectorOwner"); - Permission toRemove = Permission.tenants(TenantsPermission.Action.DELETE); - try { - // Arrange - roles.createRole(myRole, - // Create an extra permission so that the role would not be - // deleted with its otherwise only permission is removed. - Permission.cluster(ClusterPermission.Action.READ), - Permission.tenants(TenantsPermission.Action.DELETE)); - - // Act - Result response = roles.removePermissions(myRole, toRemove); - assertNull("remove-permissions operation error", response.getError()); - - // Assert - assertFalse("should not have permission " + toRemove, checkHasPermission(roles, myRole, toRemove)); - } finally { - roles.deleteRole(myRole); - } - } - - /** - * Check query builder accepts arrays of permissions, - * which is handy in combination with factory methods that create permissions - * with multiple actions. - */ - @DataMethod(source = ClientRbacTestSuite.class, method = "clients") - @Name("{class}/client={0} ") - @Test - public void testRemovePermissionsMultipleAction(String _name, Supplier rbac) { - Rbac roles = rbac.get(); - String myRole = roleName("VectorOwner"); - Permission toRemove = Permission.data("Pizza", - DataPermission.Action.READ, - DataPermission.Action.CREATE); - try { - // Arrange - roles.createRole(myRole, - Permission.data("Pizza", - DataPermission.Action.READ, - DataPermission.Action.UPDATE, - DataPermission.Action.DELETE, - DataPermission.Action.CREATE), - Permission.tenants(TenantsPermission.Action.DELETE)); - - // Act - Result response = roles.removePermissions(myRole, toRemove); - assertNull("remove-permissions operation error", response.getError()); - - // Assert - assertFalse("should not have permission " + toRemove, checkHasPermission(roles, myRole, toRemove)); - } finally { - roles.deleteRole(myRole); - } - } - - /** Prefix the role with the name of the current test for easier debugging */ - private String roleName(String name) { - return String.format("%s-%s", currentTest.getMethodName(), name); - } - - private boolean checkHasPermission(Rbac roles, String role, Permission> perm) { - return roles.hasPermission(role, perm).getResult(); - } - - /** - * Sync and async test suits should provide an implementation of this interface. - * This way the test suite can be written once with very little - * boilerplate/overhead. - */ - public interface Rbac { - Result getRole(String role); - - Result> getAll(); - - Result> getAssignedUsers(String role); - - Result> getGroupAssignments(String role); - - Result> getUserAssignments(String role); - - Result createRole(String role, Permission... permissions); - - void deleteRole(String role); - - Result hasPermission(String role, Permission perm); - - Result exists(String role); - - Result addPermissions(String role, Permission... permissions); - - Result removePermissions(String role, Permission... permissions); - - } -} diff --git a/src/test/java/io/weaviate/integration/tests/schema/SchemaTestSuite.java b/src/test/java/io/weaviate/integration/tests/schema/SchemaTestSuite.java deleted file mode 100644 index 18cc90cd9..000000000 --- a/src/test/java/io/weaviate/integration/tests/schema/SchemaTestSuite.java +++ /dev/null @@ -1,199 +0,0 @@ -package io.weaviate.integration.tests.schema; - -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateErrorMessage; -import io.weaviate.client.v1.schema.model.DataType; -import io.weaviate.client.v1.schema.model.Property; -import io.weaviate.client.v1.schema.model.Schema; -import io.weaviate.client.v1.schema.model.WeaviateClass; -import java.util.Arrays; -import java.util.List; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -public class SchemaTestSuite { - public static class testSchemaCreateBandClass { - public static WeaviateClass clazz = WeaviateClass.builder() - .className("Band") - .description("Band that plays and produces music") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); - - public static void assertResults(Result createStatus, Result schema) { - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schema); - assertNotNull(schema.getResult()); - assertEquals(1, schema.getResult().getClasses().size()); - - WeaviateClass resultClass = schema.getResult().getClasses().get(0); - assertEquals(clazz.getClassName(), resultClass.getClassName()); - assertEquals(clazz.getDescription(), resultClass.getDescription()); - } - } - - public static class testSchemaCreateRunClass { - public static WeaviateClass clazz = WeaviateClass.builder() - .className("Run") - .description("Running from the fuzz") - .vectorIndexType("hnsw") - .vectorizer("text2vec-contextionary") - .build(); - - public static void assertResults(Result createStatus, Result schemaAfterCreate, Result deleteStatus, - Result schemaAfterDelete) { - assertNotNull(createStatus); - assertTrue(createStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().size()); - assertEquals(clazz.getClassName(), schemaAfterCreate.getResult().getClasses().get(0).getClassName()); - assertEquals(clazz.getDescription(), schemaAfterCreate.getResult().getClasses().get(0).getDescription()); - assertNotNull(deleteStatus); - assertTrue(deleteStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testSchemaDeleteClasses { - public static WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - public static WeaviateClass chickenSoup = WeaviateClass.builder() - .className("ChickenSoup") - .description("A soup made in part out of chicken, not for chicken.") - .build(); - - public static void assertResults(Result pizzaCreateStatus, - Result chickenSoupCreateStatus, - Result schemaAfterCreate, - Result deletePizzaStatus, - Result deleteChickenSoupStatus, - Result schemaAfterDelete - ) { - assertNotNull(pizzaCreateStatus); - assertTrue(pizzaCreateStatus.getResult()); - assertNotNull(chickenSoupCreateStatus); - assertTrue(chickenSoupCreateStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(2, schemaAfterCreate.getResult().getClasses().size()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().stream().filter(o -> o.getClassName().equals(pizza.getClassName())).count()); - assertNotNull(deletePizzaStatus); - assertTrue(deletePizzaStatus.getResult()); - assertNotNull(deleteChickenSoupStatus); - assertTrue(deleteChickenSoupStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testSchemaDeleteAllSchema { - public static WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - public static WeaviateClass chickenSoup = WeaviateClass.builder() - .className("ChickenSoup") - .description("A soup made in part out of chicken, not for chicken.") - .build(); - public static void assertResults(Result pizzaCreateStatus, Result chickenSoupCreateStatus, - Result schemaAfterCreate, Result deleteAllStatus, Result schemaAfterDelete) { - assertNotNull(pizzaCreateStatus); - assertTrue(pizzaCreateStatus.getResult()); - assertNotNull(chickenSoupCreateStatus); - assertTrue(chickenSoupCreateStatus.getResult()); - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(2, schemaAfterCreate.getResult().getClasses().size()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().stream().filter(o -> o.getClassName().equals(pizza.getClassName())).count()); - assertEquals(1, schemaAfterCreate.getResult().getClasses().stream().filter(o -> o.getDescription().equals(chickenSoup.getDescription())).count()); - assertNotNull(deleteAllStatus); - assertTrue(deleteAllStatus.getResult()); - assertEquals(0, schemaAfterDelete.getResult().getClasses().size()); - } - } - - public static class testSchemaCreateClassesAddProperties { - public static WeaviateClass pizza = WeaviateClass.builder() - .className("Pizza") - .description("A delicious religion like food and arguably the best export of Italy.") - .build(); - public static WeaviateClass chickenSoup = WeaviateClass.builder() - .className("ChickenSoup") - .description("A soup made in part out of chicken, not for chicken.") - .build(); - public static Property newProperty = Property.builder() - .dataType(Arrays.asList(DataType.TEXT)) - .description("name") - .name("name") - .build(); - public static void assertResults(Result pizzaCreateStatus, Result chickenSoupCreateStatus, Result pizzaPropertyCreateStatus, - Result chickenSoupPropertyCreateStatus, Result schemaAfterCreate, Result deleteAllStatus, Result schemaAfterDelete) { - assertResultTrue(pizzaCreateStatus); - assertResultTrue(chickenSoupCreateStatus); - assertResultTrue(pizzaPropertyCreateStatus); - assertResultTrue(chickenSoupPropertyCreateStatus); - assertClassesSize(2, schemaAfterCreate); - - WeaviateClass resultPizzaClass = schemaAfterCreate.getResult().getClasses() - .stream().filter(o -> o.getClassName().equals(pizza.getClassName())).findFirst().get(); - assertClassEquals(pizza.getClassName(), pizza.getDescription(), resultPizzaClass); - assertPropertiesSize(1, resultPizzaClass); - assertPropertyEquals(newProperty.getName(), "word", resultPizzaClass.getProperties().get(0)); - WeaviateClass resultChickenSoupClass = schemaAfterCreate.getResult().getClasses() - .stream().filter(o -> o.getClassName().equals(chickenSoup.getClassName())).findFirst().get(); - assertClassEquals(chickenSoup.getClassName(), chickenSoup.getDescription(), resultChickenSoupClass); - assertPropertiesSize(1, resultChickenSoupClass); - assertPropertyEquals(newProperty.getName(), "word", resultChickenSoupClass.getProperties().get(0)); - - assertResultTrue(deleteAllStatus); - assertClassesSize(0, schemaAfterDelete); - } - } - - public static void assertResultTrue(Result result) { - assertNotNull(result); - assertTrue(result.getResult()); - } - - public static void assertClassesSize(int expectedSize, Result schemaAfterCreate) { - assertNotNull(schemaAfterCreate); - assertNotNull(schemaAfterCreate.getResult()); - assertNotNull(schemaAfterCreate.getResult().getClasses()); - assertEquals(expectedSize, schemaAfterCreate.getResult().getClasses().size()); - } - - public static void assertClassEquals(String expectedName, String expectedDescription, WeaviateClass schemaClass) { - assertEquals(expectedName, schemaClass.getClassName()); - assertEquals(expectedDescription, schemaClass.getDescription()); - } - - public static void assertPropertiesSize(int expectedSize, WeaviateClass schemaClass) { - assertNotNull(schemaClass.getProperties()); - assertEquals(expectedSize, schemaClass.getProperties().size()); - } - - public static void assertPropertyEquals(String expectedName, String expectedTokenization, Property property) { - assertEquals(expectedName, property.getName()); - assertEquals(expectedTokenization, property.getTokenization()); - } - - public static void assertPropertyEquals(String expectedName, String expectedDataType, String expectedTokenization, Property property) { - assertPropertyEquals(expectedName, expectedTokenization, property); - assertTrue(property.getDataType().size() > 0); - assertEquals(expectedDataType, property.getDataType().get(0)); - } - - public static void assertResultError(String msg, Result result) { - assertNotNull(result); - assertTrue(result.hasErrors()); - List messages = result.getError().getMessages(); - assertEquals(1, messages.size()); - assertEquals(msg, messages.get(0).getMessage()); - } -} diff --git a/src/test/java/io/weaviate/integration/tests/users/ClientUsersTestSuite.java b/src/test/java/io/weaviate/integration/tests/users/ClientUsersTestSuite.java deleted file mode 100644 index ed43bff75..000000000 --- a/src/test/java/io/weaviate/integration/tests/users/ClientUsersTestSuite.java +++ /dev/null @@ -1,331 +0,0 @@ -package io.weaviate.integration.tests.users; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assumptions.assumeTrue; - -import java.util.Arrays; -import java.util.List; -import java.util.function.Supplier; -import java.util.stream.Collectors; - -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.jupiter.api.Assertions; -import org.junit.rules.TestName; -import org.junit.runner.RunWith; -import org.testcontainers.weaviate.WeaviateContainer; - -import com.jparams.junit4.JParamsTestRunner; -import com.jparams.junit4.data.DataMethod; -import com.jparams.junit4.description.Name; - -import io.weaviate.client.Config; -import io.weaviate.client.WeaviateAuthClient; -import io.weaviate.client.WeaviateClient; -import io.weaviate.client.base.Result; -import io.weaviate.client.base.WeaviateError; -import io.weaviate.client.v1.rbac.model.BackupsPermission; -import io.weaviate.client.v1.rbac.model.Permission; -import io.weaviate.client.v1.rbac.model.Role; -import io.weaviate.client.v1.rbac.model.TenantsPermission; -import io.weaviate.client.v1.users.model.User; -import io.weaviate.client.v1.users.model.UserDb; -import io.weaviate.integration.client.WeaviateDockerImage; -import io.weaviate.integration.client.WeaviateWithRbacContainer; -import io.weaviate.integration.tests.rbac.ClientRbacTestSuite; -import io.weaviate.integration.tests.rbac.ClientRbacTestSuite.Rbac; - -@RunWith(JParamsTestRunner.class) -public class ClientUsersTestSuite { - - private static final String adminUser = "john-doe"; - private static final String API_KEY = WeaviateWithRbacContainer.makeSecret(adminUser); - - @Rule - public TestName currentTest = new TestName(); - - @ClassRule - public static WeaviateContainer weaviate = new WeaviateWithRbacContainer( - WeaviateDockerImage.WEAVIATE_DOCKER_IMAGE, - adminUser); - - public static Config config() { - return new Config("http", weaviate.getHttpHostAddress()); - } - - public static Object[][] clients() { - try { - return new Object[][] { - { "sync", - (Supplier) () -> new io.weaviate.integration.client.users.ClientUsersTest(config(), API_KEY) }, - { "async", - (Supplier) () -> new io.weaviate.integration.client.async.users.ClientUsersTest(config(), - API_KEY) } - }; - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * Roles retrieved for "current user" should be identical to the ones - * retrieved for them explicitly (by passing the username). - */ - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Test - public void testGetUserRoles(String _kind, Supplier userHandle) { - Users users = userHandle.get(); - Result myUser = users.getMyUser(); - assertNull("get my user error", myUser.getError()); - Result> responseAdminUser = users.getUserRoles(adminUser); - assertNull("get roles for user error", responseAdminUser.getError()); - - List currentRoles = myUser.getResult().getRoles().values().stream().collect(Collectors.toList()); - List adminRoles = responseAdminUser.getResult(); - - Assertions.assertArrayEquals(currentRoles.toArray(), adminRoles.toArray(), - "expect same set of roles"); - } - - /** User can be assigned a role and the role can be revoked. */ - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Test - public void testAssignRevokeRole(String _kind, Supplier userHandle) { - Users roles = userHandle.get(); - String myRole = roleName("VectorOwner"); - try { - // Arrange - roles.createRole(myRole, Permission.tenants(TenantsPermission.Action.DELETE)); - - // Act: Assign - roles.assignRoles(adminUser, myRole); - assumeTrue(checkHasRole(roles, adminUser, myRole), adminUser + " should have the assigned role"); - - // Act: Revoke - Result response = roles.revokeRoles(adminUser, myRole); - assertNull("revoke operation error", response.getError()); - - // Assert - assertFalse("should not have " + myRole + " role", checkHasRole(roles, adminUser, myRole)); - } finally { - roles.deleteRole(myRole); - } - } - - /** Admin can control the entire lifecycle of a 'db' user. */ - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testUserLifecycle_db(String _kind, Supplier usersHandle) { - DbUsers db = usersHandle.get().db(); - - Result created = db.create("dynamic-dave"); - assertNull("create user", created.getError()); - - UserDb dave = db.getUser("dynamic-dave").getResult(); - assertTrue("created user is active", dave.isActive()); - - boolean ok = db.activate("dynamic-dave").getResult(); - assertFalse("second activation is a no-op", ok); - - db.deactivate("dynamic-dave", true); - dave = db.getUser("dynamic-dave").getResult(); - assertFalse("user deactivated", dave.isActive()); - - ok = db.deactivate("dynamic-dave", true).getResult(); - assertFalse("second deactivation is a no-op", ok); - - db.delete("dynamic-dave"); - WeaviateError error = db.getUser("dynamic-dave").getError(); - // We do not return 404 errors, or any errors without an error message. - // Changing that would mean breaking existing code. - // assertEquals(404, error.getStatusCode(), "user not found after deletion"); - assertNull("getting a deleted user produces no error", error); - assertNull("user is deleted", db.getUser("dynamic-dave").getResult()); - } - - /** Admin can obtain and rotate API keys for users. */ - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testRotateApiKeys_db(String _kind, Supplier usersHandle) { - DbUsers db = usersHandle.get().db(); - - Result created = db.create("api-ashley"); - assertNull("create user", created.getError()); - - String apiKey = created.getResult(); - // It doesn't matter that we're using a sync client here, - // as we only want to check that the key is valid. - WeaviateClient clientAshley = assertDoesNotThrow(() -> WeaviateAuthClient.apiKey(config(), apiKey), - "connect with api key"); - - User ashley = clientAshley.users().myUserGetter().run().getResult(); - assertEquals(ashley.getUserId(), "api-ashley"); - - String newKey = db.rotateKey("api-ashley").getResult(); - clientAshley = assertDoesNotThrow(() -> WeaviateAuthClient.apiKey(config(), newKey), "connect with new api key"); - - ashley = clientAshley.users().myUserGetter().run().getResult(); - assertEquals(ashley.getUserId(), "api-ashley"); - - db.delete("api-ashley"); - } - - /** Admin can list dynamic users. */ - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testListUsers_db(String _kind, Supplier usersHandle) { - DbUsers db = usersHandle.get().db(); - - Arrays.asList("jim", "pam", "dwight").forEach(u -> db.create(u)); - - List all = db.getAll().getResult(); - // 3 created + admin user defined in WeaviateWithRbacContainer - assertEquals(4, all.size(), "expected number of dynamic users"); - - UserDb pam = db.getUser("pam").getResult(); - assertTrue("pam is one of the users", all.contains(pam)); - - Arrays.asList("jim", "pam", "dwight").forEach(u -> db.delete(u)); - } - - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testFetchStaticUsers_db(String _kind, Supplier usersHandle) { - DbUsers db = usersHandle.get().db(); - UserDb envUser = db.getUser(adminUser).getResult(); - assertEquals("db_env_user", envUser.getUserType()); - } - - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testAssignRevokeRole_db(String _kind, Supplier usersHandle) { - Rbac rbac = usersHandle.get(); - DbUsers db = usersHandle.get().db(); - - db.create("role-rick"); - rbac.createRole("TestRole"); - - db.assignRoles("role-rick", "TestRole"); - assertTrue("role-rick has TestRole", - checkHasRole(rbac, "role-rick", "TestRole")); - - db.revokeRoles("role-rick", "TestRole"); - assertFalse("TestRole is revoked", - checkHasRole(rbac, "role-rick", "TestRole")); - - db.delete("role-rick"); - rbac.deleteRole("TestRole"); - } - - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testAssignRevokeRole_oidc(String _kind, Supplier usersHandle) { - Rbac rbac = usersHandle.get(); - OidcUsers oidc = usersHandle.get().oidc(); - rbac.createRole("TestRole"); - - oidc.assignRoles("role-rick", "TestRole"); - assertTrue("role-rick has TestRole", - checkHasRole(rbac, "role-rick", "TestRole")); - - oidc.revokeRoles("role-rick", "TestRole"); - assertFalse("TestRole is revoked", - checkHasRole(rbac, "role-rick", "TestRole")); - - rbac.deleteRole("TestRole"); - } - - @DataMethod(source = ClientUsersTestSuite.class, method = "clients") - @Name("{0}") - @Test - public void testFetchAssignedRolesWithPermissions(String _kind, Supplier usersHandle) { - Rbac rbac = usersHandle.get(); - DbUsers db = usersHandle.get().db(); - - rbac.createRole("TestRole", - Permission.backups("Pizza", BackupsPermission.Action.MANAGE), - Permission.tenants(TenantsPermission.Action.READ)); - db.create("permission-peter"); - db.assignRoles("permission-peter", "TestRole"); - - List roles = db.getAssignedRoles("permission-peter", true).getResult(); - assertEquals(1, roles.size(), "expected n. of roles"); - Role testRole = roles.get(0); - assertEquals(2, testRole.permissions.size(), "expected n. of permissions"); - - db.delete("permission-peter"); - rbac.deleteRole("TestRole"); - } - - /** Prefix the role with the name of the current test for easier debugging */ - private String roleName(String name) { - return String.format("%s-%s", currentTest.getMethodName(), name); - } - - private boolean checkHasRole(Rbac roles, String user, String role) { - return roles.getAssignedUsers(role).getResult().contains(user); - } - - /** - * Sync and async test suits should provide an implementation of this interface. - * This way the test suite can be written once with very little - * boilerplate/overhead. - * - * Extends {@link ClientRbacTestSuite.Rbac} because many tests require the - * functionality for creating / deleting / verifying roles. - */ - public interface Users extends ClientRbacTestSuite.Rbac { - Result getMyUser(); - - Result> getUserRoles(String user); - - Result assignRoles(String user, String... roles); - - Result revokeRoles(String user, String... roles); - - DbUsers db(); - - OidcUsers oidc(); - } - - public interface DbUsers { - Result assignRoles(String user, String... roles); - - Result revokeRoles(String user, String... roles); - - Result> getAssignedRoles(String user, boolean includePermissions); - - Result create(String user); - - Result rotateKey(String user); - - Result delete(String user); - - Result activate(String user); - - Result deactivate(String user, boolean revokeKey); - - Result getUser(String user); - - Result> getAll(); - } - - public interface OidcUsers { - Result assignRoles(String user, String... roles); - - Result revokeRoles(String user, String... roles); - - Result> getAssignedRoles(String user, boolean includePermissions); - } -} diff --git a/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java b/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java new file mode 100644 index 000000000..ebea2fea7 --- /dev/null +++ b/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java @@ -0,0 +1,60 @@ +package io.weaviate.testutil.transport; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CompletableFuture; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.MessageOrBuilder; +import com.google.protobuf.util.JsonFormat; + +import io.weaviate.client6.v1.internal.grpc.GrpcTransport; +import io.weaviate.client6.v1.internal.grpc.Rpc; + +public class MockGrpcTransport implements GrpcTransport { + + @FunctionalInterface + public interface AssertFunction { + void apply(String json); + } + + private List requests = new ArrayList<>(); + + public void assertNext(AssertFunction... assertions) { + var assertN = Math.min(assertions.length, requests.size()); + try { + for (var i = 0; i < assertN; i++) { + var req = requests.get(i); + String json; + try { + json = JsonFormat.printer().print(req); + } catch (InvalidProtocolBufferException e) { + throw new RuntimeException(e); + } + assertions[i].apply(json); + } + } finally { + requests.clear(); + } + } + + @Override + public ResponseT performRequest(RequestT request, + Rpc rpc) { + var r = rpc.marshal(request); + requests.add((MessageOrBuilder) r); + return null; + } + + @Override + public CompletableFuture performRequestAsync(RequestT request, + Rpc rpc) { + requests.add((MessageOrBuilder) rpc.marshal(request)); + return null; + } + + @Override + public void close() throws IOException { + } +} diff --git a/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java b/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java new file mode 100644 index 000000000..587cb2548 --- /dev/null +++ b/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java @@ -0,0 +1,63 @@ +package io.weaviate.testutil.transport; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +import io.weaviate.client6.v1.internal.rest.BooleanEndpoint; +import io.weaviate.client6.v1.internal.rest.Endpoint; +import io.weaviate.client6.v1.internal.rest.RestTransport; + +public class MockRestTransport implements RestTransport { + + private record Request(String method, String requestUrl, String body, + Map queryParameters) { + + Request(RequestT req, Endpoint ep) { + this(ep.method(req), ep.requestUrl(req), ep.body(req), ep.queryParameters(req)); + } + } + + @FunctionalInterface + public interface AssertFunction { + void apply(String method, String requestUrl, String body, Map queryParameters); + } + + private List> requests = new ArrayList<>(); + + public void assertNext(AssertFunction... assertions) { + var assertN = Math.min(assertions.length, requests.size()); + try { + for (var i = 0; i < assertN; i++) { + var req = requests.get(i); + assertions[i].apply(req.method, req.requestUrl, req.body, req.queryParameters); + } + } finally { + requests.clear(); + } + } + + @SuppressWarnings("unchecked") + @Override + public ResponseT performRequest(RequestT request, + Endpoint endpoint) throws IOException { + requests.add(new Request<>(request, endpoint)); + if (endpoint instanceof BooleanEndpoint) { + return (ResponseT) Boolean.TRUE; + } + return null; + } + + @Override + public CompletableFuture performRequestAsync(RequestT request, + Endpoint endpoint) { + requests.add(new Request<>(request, endpoint)); + return null; + } + + @Override + public void close() throws IOException { + } +} diff --git a/src/test/java/io/weaviate/testutil/truststore/SingleTrustManagerFactory.java b/src/test/java/io/weaviate/testutil/truststore/SingleTrustManagerFactory.java new file mode 100644 index 000000000..19f6456f0 --- /dev/null +++ b/src/test/java/io/weaviate/testutil/truststore/SingleTrustManagerFactory.java @@ -0,0 +1,50 @@ +package io.weaviate.testutil.truststore; + +import java.security.InvalidAlgorithmParameterException; +import java.security.KeyStore; +import java.security.KeyStoreException; + +import javax.net.ssl.ManagerFactoryParameters; +import javax.net.ssl.TrustManager; +import javax.net.ssl.TrustManagerFactory; +import javax.net.ssl.TrustManagerFactorySpi; + +/** TrustManagerFactory which always returns the same {@code TrustManager}. */ +public final class SingleTrustManagerFactory extends TrustManagerFactory { + + /** Create a factory that will return {@code TrustManager tm}. */ + public static TrustManagerFactory create(TrustManager tm) { + return new SingleTrustManagerFactory(tm); + } + + protected SingleTrustManagerFactory(TrustManager tm) { + super(new SingleTrustManagerFactorySpi(tm), null, TrustManagerFactory.getDefaultAlgorithm()); + } + + /** + * Naive {@code TrustManagerFactorySpi} implementation + * which always returns the same {@code TrustManager}. + */ + private static final class SingleTrustManagerFactorySpi extends TrustManagerFactorySpi { + private final TrustManager[] trustManagers; + + private SingleTrustManagerFactorySpi(TrustManager tm) { + this.trustManagers = new TrustManager[] { tm }; + } + + @Override + protected void engineInit(KeyStore ks) throws KeyStoreException { + return; + } + + @Override + protected void engineInit(ManagerFactoryParameters spec) throws InvalidAlgorithmParameterException { + return; + } + + @Override + protected TrustManager[] engineGetTrustManagers() { + return trustManagers; + } + } +} diff --git a/src/test/java/io/weaviate/testutil/truststore/SpyTrustManager.java b/src/test/java/io/weaviate/testutil/truststore/SpyTrustManager.java new file mode 100644 index 000000000..a4a881d0b --- /dev/null +++ b/src/test/java/io/weaviate/testutil/truststore/SpyTrustManager.java @@ -0,0 +1,45 @@ +package io.weaviate.testutil.truststore; + +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; +import java.util.Optional; + +import javax.net.ssl.TrustManagerFactory; +import javax.net.ssl.X509TrustManager; + +/** + * Test fixture that records when this TrustManager has been used. + * Combine with {@link SingleTrustManagerFactory#create} to mock + * a custom TrustStore. + */ +public class SpyTrustManager implements X509TrustManager { + private boolean used = false; + + public boolean wasUsed() { + return this.used; + } + + @Override + public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { + this.used = true; + } + + @Override + public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { + this.used = true; + } + + @Override + public X509Certificate[] getAcceptedIssuers() { + this.used = true; + return new X509Certificate[0]; + } + + public static Optional getSpy(TrustManagerFactory tmf) { + var managers = tmf.getTrustManagers(); + if (managers.length == 0) { + return Optional.empty(); + } + return Optional.of((SpyTrustManager) managers[0]); + } +} diff --git a/src/test/resources/docker-compose-proxy.yaml b/src/test/resources/docker-compose-proxy.yaml deleted file mode 100644 index af6d078a3..000000000 --- a/src/test/resources/docker-compose-proxy.yaml +++ /dev/null @@ -1,26 +0,0 @@ ---- -version: '3.4' -services: - weaviate: - command: - - --host - - 0.0.0.0 - - --port - - '8080' - - --scheme - - http - image: semitechnologies/weaviate:1.25.0 - restart: on-failure:0 - environment: - LOG_LEVEL: "debug" - QUERY_DEFAULTS_LIMIT: 25 - AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true' - PERSISTENCE_DATA_PATH: "./data" - VIRTUAL_HOST: weaviate.local - VIRTUAL_PORT: 8080 - DISABLE_TELEMETRY: 'true' - proxy: - image: nginxproxy/nginx-proxy:alpine - volumes: - - /var/run/docker.sock:/tmp/docker.sock:ro -... diff --git a/src/test/resources/image/base64.txt b/src/test/resources/image/base64.txt deleted file mode 100644 index e2012627c..000000000 --- a/src/test/resources/image/base64.txt +++ /dev/null @@ -1 +0,0 @@ -iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV/TSou0ONhBxCFD62RBVMRRq1CECqFWaNXB5NIvaNKSpLg4Cq4FBz8Wqw4uzro6uAqC4AeIm5uToouU+L+k0CLGg+N+vLv3uHsHCK0q08zAOKDplpFJJcVcflUMviKACEKIwy8zsz4nSWl4jq97+Ph6l+BZ3uf+HBG1YDLAJxLPsrphEW8QT29adc77xFFWllXic+Ixgy5I/Mh1xeU3ziWHBZ4ZNbKZeeIosVjqYaWHWdnQiKeIY6qmU76Qc1nlvMVZqzZY5578heGCvrLMdZojSGERS5AgQkEDFVRhIUGrToqJDO0nPfzDjl8il0KuChg5FlCDBtnxg//B727N4uSEmxROAn0vtv0RB4K7QLtp29/Htt0+AfzPwJXe9ddawMwn6c2uFjsCBraBi+uupuwBlzvA0FNdNmRH8tMUikXg/Yy+KQ8M3gL9a25vnX2cPgBZ6ip9AxwcAqMlyl73eHeot7d/z3T6+wEPO3J/B8olWgAAAAlwSFlzAAAuIwAALiMBeKU/dgAAAAd0SU1FB+UEDQgmFS2naPsAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAADElEQVQI12NgYGAAAAAEAAEnNCcKAAAAAElFTkSuQmCC \ No newline at end of file diff --git a/src/test/resources/image/pixel.png b/src/test/resources/image/pixel.png deleted file mode 100644 index e48f3bed9..000000000 Binary files a/src/test/resources/image/pixel.png and /dev/null differ diff --git a/src/test/resources/json/batch-reference-response.json b/src/test/resources/json/batch-reference-response.json deleted file mode 100644 index f9752e6b6..000000000 --- a/src/test/resources/json/batch-reference-response.json +++ /dev/null @@ -1,30 +0,0 @@ -[ - { - "from": "weaviate://localhost/Pizza/97fa5147-bdad-4d74-9a81-f8babc811b09/otherFoods", - "to": "weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af", - "result": { - "status": "SUCCESS" - } - }, - { - "from": "weaviate://localhost/Pizza/97fa5147-bdad-4d74-9a81-f8babc811b09/otherFoods", - "to": "weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09", - "result": { - "status": "SUCCESS" - } - }, - { - "from": "weaviate://localhost/Soup/07473b34-0ab2-4120-882d-303d9e13f7af/otherFoods", - "to": "weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09", - "result": { - "status": "SUCCESS" - } - }, - { - "from": "weaviate://localhost/Soup/07473b34-0ab2-4120-882d-303d9e13f7af/otherFoods", - "to": "weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af", - "result": { - "status": "SUCCESS" - } - } -] \ No newline at end of file diff --git a/src/test/resources/json/c11y-concepts.json b/src/test/resources/json/c11y-concepts.json deleted file mode 100644 index b45f9861a..000000000 --- a/src/test/resources/json/c11y-concepts.json +++ /dev/null @@ -1,1077 +0,0 @@ -{ - "concatenatedWord": { - "concatenatedNearestNeighbors": [ - { - "distance": 6.0745554, - "word": "hawaiian" - }, - { - "distance": 6.5974355, - "word": "pizza" - }, - { - "distance": 6.7668314, - "word": "restaurant" - }, - { - "distance": 6.807268, - "word": "airwaysaspiring" - }, - { - "distance": 6.82173, - "word": "pizzas" - }, - { - "distance": 6.833187, - "word": "staple" - }, - { - "distance": 6.8396683, - "word": "grocery" - }, - { - "distance": 6.9182153, - "word": "takeaway" - }, - { - "distance": 6.9303083, - "word": "lunch" - }, - { - "distance": 6.940148, - "word": "dine" - }, - { - "distance": 6.9787927, - "word": "hearty" - }, - { - "distance": 7.1244626, - "word": "baked" - } - ], - "concatenatedVector": [ - -0.07865515, - 0.08871324, - 0.42788798, - 0.5358525, - 0.09123387, - -0.11343707, - 0.44425657, - 0.26728064, - 0.38575152, - 0.14872222, - 0.33235243, - -0.44003117, - 0.13426578, - -0.1225081, - -0.36872154, - -0.5064955, - 0.39692634, - -0.22402388, - -0.49067494, - 0.45195416, - -0.4633432, - 0.318872, - 0.29520974, - -0.0022671786, - -0.037631713, - -0.5499455, - 0.4896287, - -0.43759498, - 0.3182471, - 0.22042018, - -0.25935882, - 0.18488495, - 0.47380337, - 0.034772173, - 0.11336113, - 0.022295052, - -0.37251422, - 0.18011113, - -0.111479126, - 0.40448704, - -0.52054584, - 0.49514318, - 0.014420288, - -0.24101351, - -0.2579445, - 0.06467095, - 0.24319297, - 0.21934102, - -0.47442645, - 0.5952003, - -0.44827464, - -0.20675421, - -0.9021026, - 0.06201321, - 0.023698112, - -0.06356617, - -0.02619523, - 0.22769077, - 0.08863362, - -0.057199083, - 0.036095016, - -0.15452224, - 0.2478824, - 0.20559771, - -0.1213997, - 0.38986617, - -0.01567674, - -0.46534434, - -0.27383524, - -0.70538366, - -0.030724455, - 0.085517034, - 0.3465476, - 0.33729467, - 0.43092534, - 0.50168145, - 0.2765052, - -0.59158814, - 0.4186119, - -0.29736066, - -0.20526473, - -0.12704188, - 0.017673172, - -0.3116862, - -0.019558126, - -0.1207759, - -0.14670497, - 0.53386444, - 0.17808244, - 0.29652932, - -0.24511968, - -0.052873187, - -0.3825485, - 0.053382494, - -0.44396767, - 0.21486941, - -0.5526864, - -0.07335711, - -0.31014425, - 0.4842764, - -0.61581635, - -0.19214135, - 0.64190537, - -0.13249485, - -0.2993014, - -0.17160815, - 0.43714792, - -0.24513614, - -0.23654689, - -0.30521443, - -0.47132117, - 0.06357252, - 0.5766216, - -0.47442478, - -0.08547126, - -0.22615463, - 0.24549387, - -0.006096349, - 0.56937385, - 0.24147405, - 0.40249315, - 0.030898053, - -0.13227114, - 0.43172216, - -0.08153788, - -0.028936785, - 1.3823093, - 0.34321716, - 0.63252974, - 0.34049472, - 0.43740368, - -0.27101186, - -0.23439226, - -0.48770827, - 0.037356764, - -0.16934666, - 0.062240142, - 0.22333209, - -0.65105206, - 0.24102288, - -0.20709378, - -0.3288891, - -0.15252586, - -0.25382227, - 0.25009915, - 0.2578068, - 0.16626526, - 0.54923224, - -0.36599952, - 0.1336174, - -0.021931497, - 0.4385701, - -0.6664987, - -0.44489092, - 0.07506341, - 0.34304154, - 0.5263805, - -0.1986053, - -0.40256158, - 0.060597926, - -0.29683635, - 0.19951014, - 0.5777565, - -0.49989802, - -0.091936946, - -0.058232214, - 0.63763094, - -0.84607387, - 0.48716956, - -0.08739759, - -0.111022964, - 0.46852702, - -0.14786111, - 0.43295294, - -0.10259147, - -0.12194576, - 0.15458052, - -0.07657412, - 0.32553917, - 0.109827906, - -0.19371101, - -1.5031475, - 0.9902519, - 0.07152735, - -0.41384843, - -0.07210576, - -0.45354682, - -0.13733163, - 0.24001125, - 0.27800104, - 0.19993371, - 0.8229108, - 0.3478525, - 0.21116501, - -0.3862816, - -0.07042119, - 0.5733529, - -0.0048542, - 0.1691393, - -0.39752468, - -0.80107135, - -0.30471995, - 0.13429387, - 0.11919824, - -0.25916463, - 0.44306758, - 0.15293902, - -0.4125588, - -0.08667275, - 0.23485246, - 0.14025524, - 0.3097815, - -0.39768744, - -0.24019356, - -0.11252514, - 0.14480413, - 0.68458563, - 0.5119607, - -0.5720334, - 0.7059086, - 0.18562423, - -0.4158669, - -0.2633501, - -0.46808273, - -0.43290788, - -0.18156323, - -0.37919116, - 0.041051034, - 0.018170765, - 0.07815445, - -0.5476313, - -0.5114568, - 0.7294956, - 0.121626444, - 0.11769245, - 0.011030668, - -0.18284094, - 1.1541716, - 0.11795205, - 0.47623292, - -0.26022142, - -0.004430898, - -0.36367625, - 0.15231839, - 0.32886016, - -0.0020631633, - -0.2825272, - -0.14964524, - 0.35404703, - -0.3210202, - 0.47766423, - 0.24338543, - 0.16629688, - -0.60500956, - 0.19153677, - -0.39589113, - 0.25296953, - 0.28848004, - -0.4586026, - -0.08774544, - -0.0663831, - 0.5769463, - -0.46365094, - 0.6755943, - -0.16594836, - -0.49338415, - -0.5585334, - -0.35677913, - -0.16872211, - -0.0031324897, - -0.36363345, - -0.10664197, - -0.362599, - -0.30449495, - -0.2439807, - -0.3423311, - -0.25374964, - 0.0413369, - 1.0162013, - 0.28762668, - 0.42618066, - -0.0817572, - 0.59374475, - -0.43595338, - 0.49247718, - 0.040715925, - -0.43123463, - 0.16545625, - -0.15982632, - 0.1835575, - -0.12526542, - -0.013434593, - -0.1251056, - -0.49174815, - -0.066274114, - -0.00039878697, - -0.41586012, - 0.09795559, - -0.15743022, - -0.044795025 - ], - "concatenatedWord": "pizzaHawaii", - "singleWords": [ - "pizza", - "hawaii" - ] - }, - "individualWords": [ - { - "info": { - "nearestNeighbors": [ - { - "word": "pizza" - }, - { - "distance": 6.860836, - "word": "burger" - }, - { - "distance": 6.901139, - "word": "pasta" - }, - { - "distance": 6.963236, - "word": "sandwiches" - }, - { - "distance": 7.2686925, - "word": "burgers" - }, - { - "distance": 7.307101, - "word": "restaurant" - }, - { - "distance": 7.4022965, - "word": "fries" - }, - { - "distance": 7.42733, - "word": "pastries" - }, - { - "distance": 7.4588695, - "word": "steak" - }, - { - "distance": 7.4784856, - "word": "pie" - }, - { - "distance": 7.522779, - "word": "pies" - }, - { - "distance": 7.539552, - "word": "salad" - } - ], - "vector": [ - -0.747432, - -0.253204, - 0.701512, - 0.78443, - 0.347335, - -0.005733, - -0.070146, - 0.283653, - 0.462958, - -0.761068, - 0.815424, - -0.798153, - 0.120497, - -0.604088, - -0.576769, - -0.469757, - 0.067009, - 0.14941, - -0.840669, - 0.178351, - -0.465444, - -0.233915, - -0.143821, - 0.46548, - 0.229792, - -0.41497, - 0.024069, - -0.628307, - 0.073251, - 0.365395, - 0.488705, - 0.144798, - 0.266692, - -0.867114, - 0.054428, - -0.298867, - -0.340957, - 0.242791, - 0.23625, - 0.534564, - -1.025632, - 0.884974, - 0.045444, - 0.494654, - -1.351491, - 0.823141, - -0.131665, - 0.373821, - -0.158863, - 0.592558, - -0.296609, - -0.10735, - -1.103021, - -0.299127, - 0.28986, - -0.227783, - -0.053262, - 0.236325, - 0.753271, - 0.060004, - -0.366598, - -0.362751, - 1.292768, - 0.840196, - -0.32665, - -0.18148, - -0.251365, - -0.31975, - -0.270984, - -0.934678, - 0.019564, - -0.049968, - 0.354078, - 0.081094, - 0.451742, - -0.179957, - -0.493363, - -0.618808, - -0.068349, - 0.176888, - -0.075181, - -0.503386, - 0.390726, - -0.523347, - 0.095495, - 0.60636, - 0.677743, - 0.461889, - 0.245549, - 0.534579, - 0.023296, - -0.162533, - -0.03956, - 0.369697, - -0.622898, - -0.319155, - -0.271832, - 0.045806, - -0.530982, - 0.534429, - -0.381173, - -0.31268, - 0.365652, - -0.614851, - -0.678037, - 0.112478, - 0.716976, - 0.351578, - -0.124345, - -0.177623, - -0.795375, - -0.218781, - 0.399274, - -0.084948, - 0.370914, - -0.507065, - 0.12941, - -0.136311, - 0.78805, - -0.186759, - -0.354991, - 0.425896, - -0.310242, - 0.364228, - -0.173566, - -0.213017, - 1.379559, - 1.137784, - 0.842461, - 0.469281, - 0.140955, - 0.060407, - -0.287106, - 0.205187, - 0.170765, - -0.355197, - 0.466801, - 0.160592, - -0.869234, - 0.019616, - -0.153841, - -0.468116, - -0.089897, - -0.674332, - 0.801837, - 0.894284, - -0.164153, - 0.503111, - -0.294844, - 0.08423, - -0.302124, - 0.833927, - -0.753884, - -0.093455, - -0.650193, - 0.676729, - 0.9884, - 0.364221, - -1.127582, - -0.194604, - -0.783828, - 0.008414, - 0.378146, - -0.845275, - 0.482896, - 0.161112, - 1.679208, - -0.688471, - 0.160908, - -0.487417, - 0.079343, - 0.496713, - -0.12827, - 0.552365, - -0.025377, - 0.342464, - 1.045409, - -0.119197, - 0.247152, - 0.01279, - -1.136957, - -1.072416, - 1.10327, - 0.354265, - -0.927519, - 0.368547, - -0.376529, - 0.037091, - 0.428073, - 0.771445, - 0.039672, - 0.524906, - 0.757098, - 0.525533, - -0.142189, - -0.664557, - 0.017698, - 0.147761, - -0.304413, - -0.370367, - -0.12105, - -0.017026, - -0.610467, - -0.220861, - -0.8728, - 0.476886, - 0.350064, - -0.264544, - 0.098767, - 0.00356, - -0.183117, - -0.224222, - -0.474527, - -0.355554, - -0.016545, - -0.217931, - 0.797495, - 0.12016, - -1.051909, - 0.300679, - 0.364978, - -0.577758, - -0.590415, - 0.038425, - -0.634771, - -1.149951, - -0.800959, - -0.739334, - 0.124385, - -0.059298, - -0.231165, - -0.511844, - 0.807002, - 0.463749, - -0.191466, - 0.113197, - 0.343505, - 1.101156, - 0.799711, - 0.543142, - -0.381489, - 0.213236, - -0.280066, - -0.131804, - -0.463376, - -0.041616, - -0.107123, - 0.150678, - 0.201666, - -0.438337, - 0.325349, - 0.050856, - 0.381812, - -0.743403, - 0.248768, - 0.145376, - 0.096119, - -0.065895, - -0.867558, - -0.514914, - 0.159438, - 0.612731, - -0.241292, - 0.810517, - -0.335041, - -0.195351, - -0.530187, - 0.941679, - -0.296072, - -0.204601, - -0.562161, - -0.192538, - -0.270239, - 0.023565, - 0.243644, - -0.881082, - 0.022304, - 0.583467, - 0.827284, - 0.2081, - -0.49713, - -0.491881, - 0.601143, - -0.042953, - 0.032942, - 0.134457, - -0.869794, - 0.55974, - -0.36495, - -0.114759, - -0.021506, - 0.277681, - -0.005913, - -0.903242, - 0.002544, - 0.024853, - -0.961343, - -0.051675, - -0.252151, - -0.241794 - ] - }, - "present": true, - "word": "pizza" - }, - { - "info": { - "nearestNeighbors": [ - { - "word": "hawaii" - }, - { - "distance": 5.351279, - "word": "honolulu" - }, - { - "distance": 6.4651327, - "word": "idaho" - }, - { - "distance": 7.0383925, - "word": "alaska" - }, - { - "distance": 7.209623, - "word": "florida" - }, - { - "distance": 7.293795, - "word": "oregon" - }, - { - "distance": 7.352619, - "word": "indiana" - }, - { - "distance": 7.3835196, - "word": "nevada" - }, - { - "distance": 7.4254637, - "word": "utah" - }, - { - "distance": 7.4675584, - "word": "illinois" - }, - { - "distance": 7.484017, - "word": "iowa" - }, - { - "distance": 7.494672, - "word": "rhode" - } - ], - "vector": [ - 0.340677, - 0.3031, - 0.256322, - 0.379991, - -0.069345, - -0.180969, - 0.766794, - 0.257015, - 0.337342, - 0.719173, - 0.02946, - -0.215484, - 0.142899, - 0.179449, - -0.238273, - -0.529531, - 0.603789, - -0.458172, - -0.271224, - 0.623507, - -0.462026, - 0.665477, - 0.570488, - -0.295551, - -0.20531, - -0.634577, - 0.781541, - -0.318016, - 0.471863, - 0.129519, - -0.728405, - 0.21002, - 0.603665, - 0.600267, - 0.150313, - 0.223668, - -0.392301, - 0.14081, - -0.32951, - 0.322927, - -0.20385, - 0.250714, - -0.005032, - -0.702287, - 0.427724, - -0.4109, - 0.478234, - 0.12248, - -0.672289, - 0.596857, - -0.543371, - -0.269082, - -0.776124, - 0.288453, - -0.143189, - 0.0394, - -0.009224, - 0.222277, - -0.328103, - -0.130687, - 0.288589, - -0.02396, - -0.407275, - -0.192304, - 0.007295, - 0.748108, - 0.132103, - -0.556634, - -0.275623, - -0.561613, - -0.062256, - 0.170468, - 0.341826, - 0.497936, - 0.417873, - 0.929078, - 0.759223, - -0.574521, - 0.723943, - -0.594721, - -0.286829, - 0.108931, - -0.216236, - -0.178972, - -0.091698, - -0.5767, - -0.663645, - 0.578994, - 0.13578, - 0.147269, - -0.41342, - 0.015885, - -0.597607, - -0.144951, - -0.331776, - 0.54971, - -0.728786, - -0.148074, - -0.171676, - 0.45283, - -0.762941, - -0.116562, - 0.81512, - 0.169949, - -0.061829, - -0.349734, - 0.261692, - -0.619284, - -0.306899, - -0.385216, - -0.268135, - 0.240612, - 0.687821, - -0.718632, - -0.371631, - -0.05002, - 0.31828, - 0.07555, - 0.432261, - 0.509982, - 0.877446, - -0.216771, - -0.020681, - 0.474042, - -0.023835, - 0.086484, - 1.384034, - -0.154987, - 0.5009, - 0.259744, - 0.623281, - -0.478816, - -0.20134, - -0.922163, - -0.046292, - -0.052816, - -0.191425, - 0.262671, - -0.514249, - 0.379848, - -0.240484, - -0.241592, - -0.191795, - 0.009843, - -0.095848, - -0.141273, - 0.373442, - 0.578151, - -0.410615, - 0.164584, - 0.153753, - 0.190676, - -0.611707, - -0.665246, - 0.529809, - 0.133815, - 0.236688, - -0.551505, - 0.052036, - 0.220613, - 0.008514, - 0.31933, - 0.702915, - -0.283342, - -0.452365, - -0.195764, - -0.015452, - -0.944893, - 0.69174, - 0.16342, - -0.230385, - 0.450854, - -0.160145, - 0.35808, - -0.151006, - -0.413137, - -0.403981, - -0.049849, - 0.374689, - 0.170672, - 0.397717, - -1.773222, - 0.919388, - -0.105753, - -0.09177, - -0.348401, - -0.501838, - -0.246697, - 0.122094, - -0.031395, - 0.30042, - 1.009764, - 0.09125, - 0.014052, - -0.539331, - 0.30211, - 0.921756, - -0.100546, - 0.466063, - -0.414553, - -1.227454, - -0.485108, - 0.601269, - 0.33242, - 0.125593, - 0.421863, - 0.029339, - -0.505366, - -0.202946, - 0.379876, - 0.343014, - 0.644609, - -0.349508, - -0.167861, - -0.172706, - 0.372244, - 0.61379, - 0.757625, - -0.271145, - 0.959993, - 0.073167, - -0.314359, - -0.058276, - -0.78567, - -0.306337, - 0.425629, - -0.114737, - 0.530363, - -0.048427, - 0.164339, - -0.74606, - -0.511214, - 0.680898, - -0.092889, - 0.311539, - -0.053029, - -0.512867, - 1.187413, - -0.30952, - 0.43428, - -0.184185, - -0.140911, - -0.416101, - 0.330467, - 0.825603, - 0.022737, - -0.392508, - -0.337952, - 0.449592, - -0.247461, - 0.573168, - 0.364104, - 0.031166, - -0.518235, - 0.155652, - -0.735273, - 0.351317, - 0.510678, - -0.202182, - 0.180095, - -0.207976, - 0.554509, - -0.603073, - 0.590996, - -0.059925, - -0.680255, - -0.576307, - -1.17093, - -0.088872, - 0.123191, - -0.239154, - -0.052784, - -0.42051, - -0.510193, - -0.549728, - -0.004527, - -0.426839, - -0.298586, - 1.134655, - 0.337491, - 1.005109, - 0.175396, - 0.589106, - -0.68237, - 0.780612, - -0.018061, - -0.156252, - -0.081765, - -0.031211, - 0.370606, - -0.190324, - -0.195968, - -0.199841, - -0.233736, - -0.109424, - -0.016232, - -0.073835, - 0.191776, - -0.098039, - 0.078726 - ] - }, - "present": true, - "word": "hawaii" - } - ] -} \ No newline at end of file diff --git a/src/test/resources/json/graphql-group-by-response.json b/src/test/resources/json/graphql-group-by-response.json deleted file mode 100644 index 1fd71a2d4..000000000 --- a/src/test/resources/json/graphql-group-by-response.json +++ /dev/null @@ -1,303 +0,0 @@ -{ - "data": { - "Get": { - "Passage": [ - { - "_additional": { - "group": { - "count": 10, - "groupedBy": { - "path": [ - "ofDocument" - ], - "value": "weaviate://localhost/Document/00000000-0000-0000-0000-00000000000a" - }, - "hits": [ - { - "_additional": { - "distance": 1.1920929e-7, - "id": "00000000-0000-0000-0000-000000000001" - }, - "name": "test-name", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.002315104, - "id": "00000000-0000-0000-0000-000000000009" - }, - "name": "name09", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0023562908, - "id": "00000000-0000-0000-0000-000000000007" - }, - "name": "name07", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0025094151, - "id": "00000000-0000-0000-0000-000000000008" - }, - "name": "name08", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0027094483, - "id": "00000000-0000-0000-0000-000000000006" - }, - "name": "name06", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0027621984, - "id": "00000000-0000-0000-0000-000000000010" - }, - "name": "name10", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0028537512, - "id": "00000000-0000-0000-0000-000000000005" - }, - "name": "name05", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0033442974, - "id": "00000000-0000-0000-0000-000000000004" - }, - "name": "name04", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.0041819215, - "id": "00000000-0000-0000-0000-000000000003" - }, - "name": "name03", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - }, - { - "_additional": { - "distance": 0.005713105, - "id": "00000000-0000-0000-0000-000000000002" - }, - "name": "name02", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000a" - } - } - ] - } - ], - "id": 0, - "maxDistance": 0.005713105, - "minDistance": 1.1920929e-7 - } - }, - "ofDocument": null - }, - { - "_additional": { - "group": { - "count": 4, - "groupedBy": { - "path": [ - "ofDocument" - ], - "value": "weaviate://localhost/Document/00000000-0000-0000-0000-00000000000b" - }, - "hits": [ - { - "_additional": { - "distance": 0.0025349855, - "id": "00000000-0000-0000-0000-000000000011" - }, - "name": "name11", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000b" - } - } - ] - }, - { - "_additional": { - "distance": 0.0028856993, - "id": "00000000-0000-0000-0000-000000000013" - }, - "name": "name13", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000b" - } - } - ] - }, - { - "_additional": { - "distance": 0.0033005476, - "id": "00000000-0000-0000-0000-000000000012" - }, - "name": "name12", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000b" - } - } - ] - }, - { - "_additional": { - "distance": 0.004168868, - "id": "00000000-0000-0000-0000-000000000014" - }, - "name": "name14", - "ofDocument": [ - { - "_additional": { - "id": "00000000-0000-0000-0000-00000000000b" - } - } - ] - } - ], - "id": 1, - "maxDistance": 0.004168868, - "minDistance": 0.0025349855 - } - }, - "ofDocument": null - }, - { - "_additional": { - "group": { - "count": 6, - "groupedBy": { - "path": [ - "ofDocument" - ], - "value": "" - }, - "hits": [ - { - "_additional": { - "distance": 0.0034632683, - "id": "00000000-0000-0000-0000-000000000016" - }, - "ofDocument": null - }, - { - "_additional": { - "distance": 0.0040759444, - "id": "00000000-0000-0000-0000-000000000017" - }, - "ofDocument": null - }, - { - "_additional": { - "distance": 0.0041413307, - "id": "00000000-0000-0000-0000-000000000015" - }, - "ofDocument": null - }, - { - "_additional": { - "distance": 0.004283905, - "id": "00000000-0000-0000-0000-000000000020" - }, - "ofDocument": null - }, - { - "_additional": { - "distance": 0.0045325756, - "id": "00000000-0000-0000-0000-000000000019" - }, - "ofDocument": null - }, - { - "_additional": { - "distance": 0.0049524903, - "id": "00000000-0000-0000-0000-000000000018" - }, - "ofDocument": null - } - ], - "id": 2, - "maxDistance": 0.0049524903, - "minDistance": 0.0034632683 - } - }, - "ofDocument": null - } - ] - } - } -} diff --git a/src/test/resources/json/graphql-response.json b/src/test/resources/json/graphql-response.json deleted file mode 100644 index d33c90e0e..000000000 --- a/src/test/resources/json/graphql-response.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "data": { - "Get": { - "Soup": [ - { - "_additional": { - "certainty": 0.9999998211860657 - }, - "name": "JustSoup" - } - ] - } - } -} diff --git a/src/test/resources/json/nested-array-object.json b/src/test/resources/json/nested-array-object.json deleted file mode 100644 index 78f09c428..000000000 --- a/src/test/resources/json/nested-array-object.json +++ /dev/null @@ -1,152 +0,0 @@ -[ - { - "firstName": "John", - "lastName": "Smith", - "profession": "Software Engineer", - "description": "Experienced software engineer with a passion for coding and problem-solving.", - "phoneAsObject": { - "input": "020 1234567", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.9 - }, - "city": "New York" - }, - { - "firstName": "Alice", - "lastName": "Johnson", - "profession": "Graphic Designer", - "description": "Creative graphic designer with a strong sense of visual aesthetics.", - "phoneAsObject": { - "input": "020 1234599", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.19 - }, - "city": "Los Angeles" - }, - { - "firstName": "David", - "lastName": "Williams", - "profession": "Accountant", - "description": "Detail-oriented accountant with a knack for numbers and financial analysis.", - "phoneAsObject": { - "input": "020 1234588", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.29 - }, - "city": "Chicago" - }, - { - "firstName": "Emily", - "lastName": "Davis", - "profession": "Marketing Manager", - "description": "Seasoned marketing manager specializing in digital marketing strategies.", - "phoneAsObject": { - "input": "020 1234511", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.39 - }, - "city": "Houston" - }, - { - "firstName": "Michael", - "lastName": "Brown", - "profession": "Doctor", - "description": "Dedicated medical doctor committed to providing top-quality healthcare.", - "phoneAsObject": { - "input": "020 1234111", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.49 - }, - "city": "San Francisco" - }, - { - "firstName": "Olivia", - "lastName": "Miller", - "profession": "Teacher", - "description": "Passionate teacher with a love for educating and nurturing young minds.", - "phoneAsObject": { - "input": "020 1234589", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.339 - }, - "city": "Miami" - }, - { - "firstName": "William", - "lastName": "Jones", - "profession": "Architect", - "description": "Innovative architect known for creating breathtaking and sustainable designs.", - "phoneAsObject": { - "input": "020 1234567", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 5.9 - }, - "city": "Seattle" - }, - { - "firstName": "Sophia", - "lastName": "Wilson", - "profession": "Chef", - "description": "Talented chef renowned for crafting exquisite culinary delights.", - "phoneAsObject": { - "input": "020 200300300", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.9009 - }, - "city": "Boston" - }, - { - "firstName": "Liam", - "lastName": "Anderson", - "profession": "Financial Analyst", - "description": "Analytical financial analyst with expertise in investment strategies.", - "phoneAsObject": { - "input": "020 1234444", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 6.9 - }, - "city": "Dallas" - }, - { - "firstName": "Ava", - "lastName": "Martin", - "profession": "Journalist", - "description": "Dedicated journalist with a passion for reporting the truth.", - "phoneAsObject": { - "input": "020 1234909", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 44.9 - }, - "city": "Phoenix" - } -] diff --git a/src/test/resources/json/nested-one-object.json b/src/test/resources/json/nested-one-object.json deleted file mode 100644 index a0d5e0149..000000000 --- a/src/test/resources/json/nested-one-object.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "firstName": "John", - "lastName": "Smith", - "profession": "Software Engineer", - "description": "Experienced software engineer with a passion for coding and problem-solving.", - "phoneAsObject": { - "input": "020 1234567", - "defaultCountry": "us" - }, - "locationAsObject": { - "latitude": 52.366667, - "longitude": 4.9 - }, - "city": "New York" -} diff --git a/src/test/resources/json/object.json b/src/test/resources/json/object.json deleted file mode 100644 index 8396f3b6a..000000000 --- a/src/test/resources/json/object.json +++ /dev/null @@ -1,3380 +0,0 @@ -{ - "additional": { - "classification": null, - "nearestNeighbors": { - "neighbors": [ - { - "concept": "incidentally", - "distance": 3.8981102, - "vector": [ - -0.322941, - -0.340085, - 0.335664, - 0.183529, - -0.165882, - 0.015477, - 0.387102, - 0.250212, - 0.073175, - 0.270737, - 0.304048, - 0.082076, - -0.022339, - -0.181574, - -0.239461, - 0.459304, - 0.016124, - -0.154906, - -0.101302, - 0.040949, - 0.014817, - 0.084976, - -0.098528, - 0.113396, - -0.089647, - -0.17516, - -0.090828, - 0.208818, - -0.290542, - 0.248148, - 0.456798, - 0.166981, - 0.084313, - 0.459641, - 0.38059, - -0.326445, - 0.118627, - 0.137644, - 0.082295, - 0.081599, - -0.028003, - -0.049906, - 0.263205, - -0.062555, - 0.164342, - 0.184101, - 0.22267, - 0.294141, - -0.283463, - -0.063424, - -0.137429, - -0.342103, - 0.301338, - -0.117036, - -0.194982, - 0.224384, - -0.055168, - 0.206236, - 0.094637, - 0.03144, - 0.25307, - -0.355714, - -0.010959, - -0.17021, - -0.008405, - 0.063036, - -0.342641, - 0.233835, - 0.195142, - -0.161493, - 0.104207, - 0.316854, - -0.295427, - 0.377952, - 0.146163, - -0.552066, - -0.116042, - 0.116787, - 0.023302, - -0.156221, - -0.182747, - -0.351632, - 0.053775, - -0.034348, - 0.465674, - 0.055485, - -0.018911, - 0.174435, - -0.245001, - 0.354368, - 0.176992, - 0.082036, - -0.281866, - -0.184241, - -0.174032, - -0.184417, - -0.314757, - -0.378275, - 0.070431, - 0.262739, - -0.275469, - -0.436348, - 0.518584, - 0.06527, - -0.093109, - 0.099664, - -0.327818, - -0.511735, - -0.099548, - 0.146536, - -0.039055, - -0.230228, - 0.313594, - 0.031414, - -0.21699, - -0.295273, - -0.123699, - 0.003918, - 0.04717, - 0.162103, - -0.204083, - 0.000085, - 0.141183, - -0.057395, - -0.168395, - 0.10808, - 1.138747, - 0.281352, - -0.003009, - 0.216404, - 0.037532, - 0.134459, - -0.182267, - -0.455974, - -0.221101, - 0.443165, - 0.063574, - -0.089152, - -0.271983, - 0.02745, - 0.279504, - -0.070895, - -0.340406, - -0.125202, - 0.014028, - 0.236531, - -0.237123, - -0.167066, - -0.426381, - -0.002772, - 0.097158, - -0.114237, - -0.374341, - 0.05578, - -0.111012, - 0.395031, - 0.129847, - -0.052845, - -0.265778, - 0.013964, - -0.331078, - -0.154082, - -0.193812, - -0.213762, - 0.000492, - 0.169129, - -0.008201, - -0.016648, - 0.051407, - 0.032163, - -0.373244, - -0.036635, - -0.163013, - -0.235041, - -0.155727, - -0.131443, - -0.052101, - -0.045942, - 0.122268, - 0.402952, - -0.206413, - -0.536407, - -0.212919, - 0.02821, - 0.276207, - 0.042331, - -0.212276, - 0.309341, - -0.072658, - 0.137924, - 0.112942, - 0.118863, - 0.115689, - 0.194036, - -0.165011, - -0.008734, - -0.060455, - 0.007518, - -0.052521, - -0.061755, - -0.207633, - -0.334688, - -0.001671, - -0.064923, - -0.167112, - 0.112803, - -0.027737, - -0.307085, - -0.082064, - 0.16081, - -0.174754, - 0.430482, - -0.141541, - -0.107376, - 0.092377, - 0.235914, - 0.054891, - -0.184741, - -0.064487, - -0.287955, - 0.079436, - 0.082164, - -0.207791, - -0.244226, - 0.09004, - 0.193599, - -0.417252, - -0.062524, - 0.17627, - -0.068009, - -0.441933, - -0.376116, - 0.24669, - 0.171513, - 0.078679, - -0.103269, - -0.034468, - -0.004532, - 0.016674, - 0.269757, - 0.080093, - -0.288255, - 0.205078, - 0.237724, - 0.194128, - 0.184396, - 0.060156, - 0.03566, - -0.108613, - 0.001435, - -0.206381, - -0.018319, - 0.21379, - 0.00309, - -0.046978, - -0.251396, - -0.054728, - -0.104331, - -0.467781, - -0.086216, - 0.124996, - 0.067289, - 0.120253, - -0.072403, - 0.36068, - -0.251972, - -0.059728, - 0.429027, - -0.144046, - -0.559687, - -0.020628, - -0.246134, - 0.203791, - 0.079697, - -0.329883, - -0.072146, - 0.016272, - -0.214656, - 0.146123, - 0.126261, - 0.151441, - -0.190285, - 0.328873, - 0.058966, - -0.033788, - 0.195126, - 0.252173, - 0.473566, - -0.176984, - 0.148068, - 0.11941, - 0.087417, - -0.17134, - -0.197395, - -0.227166, - -0.049658, - -0.126229, - 0.225313, - 0.108998, - -0.254434 - ] - }, - { - "concept": "evidently", - "distance": 3.9433544, - "vector": [ - -0.506017, - -0.227335, - -0.170688, - 0.254667, - -0.225227, - 0.029172, - 0.389764, - 0.039118, - 0.004899, - 0.249541, - 0.151876, - -0.084056, - -0.049148, - -0.222663, - -0.158012, - 0.300332, - 0.188625, - -0.079653, - -0.357298, - -0.239809, - -0.03102, - 0.570062, - 0.214828, - 0.041578, - -0.077043, - -0.25007, - -0.272628, - 0.2296, - -0.453045, - 0.313202, - 0.336442, - 0.172094, - 0.297702, - 0.326045, - 0.397406, - -0.205775, - 0.121411, - -0.085651, - -0.001219, - 0.258729, - -0.270509, - -0.362199, - 0.360256, - -0.370341, - -0.03082, - 0.26389, - 0.234869, - 0.344245, - -0.350194, - -0.087704, - -0.109405, - -0.240428, - -0.04154, - -0.113533, - -0.393884, - 0.179673, - 0.030611, - 0.285375, - 0.151488, - -0.313749, - 0.286973, - -0.261694, - -0.128603, - -0.281154, - 0.344876, - 0.131209, - 0.024187, - 0.020892, - 0.057235, - 0.073705, - -0.06279, - -0.245319, - -0.242814, - 0.128015, - 0.245253, - -0.592205, - -0.058028, - 0.08873, - 0.009025, - -0.104236, - -0.34243, - -0.59057, - 0.072481, - -0.075351, - 0.493357, - -0.008431, - -0.087928, - 0.146661, - -0.024295, - 0.517952, - 0.205143, - 0.021219, - 0.021194, - -0.200262, - -0.096434, - -0.100322, - -0.164565, - -0.556936, - -0.034567, - 0.207475, - -0.091607, - -0.320783, - 0.331166, - 0.114552, - -0.140001, - 0.016802, - -0.117952, - -0.324172, - -0.117782, - 0.156486, - 0.234893, - -0.094449, - 0.458167, - -0.105861, - -0.259806, - -0.138635, - -0.138398, - -0.322112, - -0.183126, - -0.10585, - -0.151622, - -0.02495, - 0.237107, - 0.053598, - -0.093951, - 0.201889, - 1.417932, - 0.213853, - -0.004808, - 0.233514, - -0.048028, - 0.049042, - -0.302021, - -0.479275, - -0.165347, - 0.269778, - 0.339153, - 0.030315, - -0.206584, - -0.081089, - 0.023241, - -0.313275, - -0.495716, - -0.211072, - -0.022932, - 0.302378, - -0.162556, - -0.276855, - -0.153179, - 0.260473, - 0.107419, - -0.076798, - -0.336572, - 0.027051, - -0.136533, - 0.229754, - 0.347956, - 0.024509, - 0.083866, - 0.101285, - -0.244264, - 0.018136, - -0.416192, - 0.031266, - 0.066357, - 0.154454, - 0.500492, - -0.160094, - -0.142202, - -0.358058, - -0.396187, - -0.336514, - -0.107008, - -0.056162, - -0.254087, - -0.234789, - -0.31076, - -0.060485, - -0.048159, - 0.415005, - 0.101741, - -0.23532, - -0.203593, - -0.009046, - 0.389154, - 0.223496, - -0.121943, - 0.419262, - -0.081457, - 0.13348, - -0.117724, - 0.267278, - 0.028193, - -0.200937, - -0.085669, - 0.07747, - -0.187734, - 0.104176, - -0.250149, - 0.133657, - 0.059919, - -0.074737, - -0.105059, - -0.367711, - -0.398835, - 0.389698, - 0.320226, - 0.034764, - 0.150873, - 0.199824, - -0.123159, - 0.3614, - -0.286072, - 0.171442, - -0.227024, - 0.154473, - 0.133499, - -0.029856, - 0.335002, - -0.498026, - 0.019353, - -0.090662, - 0.069056, - -0.10513, - 0.181718, - -0.040645, - -0.500025, - 0.100144, - -0.039867, - -0.10306, - -0.273265, - -0.425742, - -0.024848, - -0.003968, - 0.359059, - -0.036152, - -0.059771, - 0.12245, - -0.094177, - -0.063716, - 0.083854, - -0.043972, - 0.158261, - 0.030856, - 0.167817, - 0.221949, - -0.030042, - 0.018354, - 0.293407, - 0.072718, - -0.2698, - 0.148875, - 0.274405, - 0.181462, - -0.063743, - -0.456192, - -0.163446, - -0.02355, - -0.263554, - -0.163968, - 0.14832, - 0.058418, - 0.244596, - -0.182273, - 0.167721, - -0.120317, - 0.080172, - 0.133942, - -0.062572, - -0.634785, - 0.03162, - -0.247251, - 0.397864, - -0.032144, - -0.220495, - -0.108839, - -0.229795, - -0.024112, - 0.310433, - 0.194721, - 0.168754, - -0.097965, - 0.274597, - 0.030285, - -0.060824, - 0.291497, - 0.484997, - 0.526011, - -0.160851, - 0.028328, - -0.119129, - 0.014233, - 0.141632, - -0.068276, - -0.379339, - -0.113887, - 0.051902, - 0.189407, - 0.272404, - -0.13242 - ] - }, - { - "concept": "mistaken", - "distance": 4.152782, - "vector": [ - -0.352901, - -0.073658, - 0.195685, - -0.013746, - 0.041596, - -0.140362, - 0.23332, - -0.133818, - -0.202317, - 0.215923, - 0.214263, - 0.34102, - -0.014892, - -0.131242, - -0.227444, - 0.208949, - -0.12761, - -0.425518, - -0.344111, - -0.115745, - 0.01992, - 0.573923, - 0.004189, - 0.004264, - 0.18505, - 0.034602, - -0.312099, - -0.001494, - -0.362151, - 0.121803, - 0.731931, - 0.171623, - 0.28632, - 0.513979, - 0.389837, - -0.373878, - -0.195066, - -0.108057, - -0.064043, - 0.404135, - -0.127212, - -0.256368, - 0.352685, - -0.213579, - 0.363778, - 0.319503, - -0.10758, - 0.035552, - -0.213382, - 0.034477, - -0.293475, - -0.351622, - 0.216481, - 0.075014, - -0.287404, - 0.034142, - -0.019259, - -0.051221, - 0.416256, - -0.247224, - 0.202606, - -0.128689, - -0.319532, - -0.345124, - 0.431792, - 0.081149, - -0.074819, - -0.244276, - -0.106699, - -0.122998, - 0.14803, - 0.078901, - -0.358654, - 0.38779, - 0.172327, - -0.24508, - -0.110775, - 0.033854, - -0.200516, - -0.129187, - -0.436382, - -0.37188, - 0.174541, - -0.090131, - 0.346069, - 0.046437, - 0.154692, - 0.148545, - -0.113512, - 0.481333, - 0.278527, - -0.120291, - -0.438328, - 0.159571, - -0.21295, - -0.385814, - -0.594541, - -0.396765, - -0.048307, - -0.006704, - -0.041833, - -0.40501, - 0.459303, - -0.16939, - -0.062499, - -0.11788, - -0.237563, - -0.756369, - -0.18685, - 0.206982, - 0.2178, - 0.005617, - 0.512982, - -0.247529, - -0.380272, - -0.406993, - -0.104588, - -0.338141, - -0.052196, - 0.079453, - 0.008398, - 0.020402, - 0.353444, - -0.094504, - 0.355474, - 0.390759, - 1.531669, - -0.146171, - 0.246351, - -0.125591, - -0.28665, - -0.247712, - -0.302724, - -0.458971, - 0.006235, - 0.286579, - 0.249727, - -0.133879, - -0.243808, - 0.248174, - 0.198228, - -0.171163, - -0.437944, - -0.061696, - 0.24662, - 0.399211, - -0.169745, - 0.075094, - 0.204521, - 0.089276, - 0.124487, - 0.198393, - -0.29965, - 0.078091, - -0.181015, - 0.590517, - 0.096666, - 0.244913, - -0.072001, - 0.261155, - -0.178526, - -0.069865, - -0.443341, - -0.212309, - -0.053928, - 0.169224, - 0.21707, - -0.123619, - -0.051522, - 0.065534, - -0.228783, - 0.079054, - -0.13799, - -0.15279, - -0.041772, - -0.402479, - -0.105987, - -0.023099, - -0.030393, - 0.34228, - -0.202265, - -0.411281, - 0.071056, - 0.045628, - 0.457747, - 0.053524, - 0.04233, - 0.364402, - -0.144393, - 0.597528, - 0.106301, - 0.329269, - 0.320664, - -0.469853, - -0.141374, - 0.137587, - 0.037962, - 0.175302, - -0.443877, - 0.246079, - -0.078629, - 0.186398, - 0.110314, - -0.024757, - -0.246664, - 0.237097, - 0.278637, - -0.208992, - -0.178887, - -0.14313, - -0.212448, - 0.621441, - -0.421123, - -0.066215, - 0.040952, - 0.06162, - 0.322251, - -0.047539, - 0.075852, - -0.442978, - -0.019098, - -0.121878, - 0.095312, - -0.434705, - -0.078103, - 0.241451, - -0.359711, - 0.04524, - -0.321591, - -0.335023, - -0.095348, - -0.592684, - 0.063056, - 0.061923, - 0.371233, - -0.254765, - 0.077261, - 0.301302, - 0.024023, - 0.181724, - 0.18095, - -0.130615, - 0.009263, - 0.056572, - 0.20721, - 0.144897, - 0.195198, - 0.174608, - -0.10099, - -0.067879, - -0.279107, - -0.053673, - 0.357904, - 0.254469, - -0.062337, - -0.047321, - -0.236462, - 0.210227, - -0.244871, - 0.009477, - 0.349511, - 0.021671, - 0.060019, - -0.125397, - 0.178442, - -0.026804, - -0.02253, - 0.269912, - -0.177675, - -0.491166, - -0.037025, - -0.214296, - 0.230374, - -0.152764, - -0.192455, - -0.102679, - -0.002252, - -0.473131, - 0.195942, - 0.13761, - 0.008262, - -0.453591, - 0.263215, - 0.188276, - -0.043732, - 0.126209, - 0.511074, - 0.443107, - -0.433252, - 0.234249, - -0.289054, - -0.022334, - 0.152317, - 0.208992, - -0.408379, - 0.279457, - -0.236135, - 0.151077, - 0.40348, - 0.163209 - ] - }, - { - "concept": "theirs", - "distance": 4.1618524, - "vector": [ - -0.255131, - -0.435995, - 0.301945, - -0.055093, - -0.114746, - -0.026507, - 0.33164, - 0.009943, - 0.134545, - 0.390616, - 0.319847, - 0.318031, - -0.155683, - -0.149247, - -0.352042, - -0.147691, - -0.018752, - 0.351326, - -0.299484, - 0.219483, - 0.397212, - 0.432338, - 0.161259, - 0.0751, - -0.380089, - -0.570845, - 0.083596, - -0.111816, - -0.386444, - 0.181472, - 0.253526, - 0.492207, - 0.165617, - 0.329309, - 0.511748, - -0.295526, - 0.180312, - 0.11533, - 0.146503, - 0.571723, - -0.316048, - 0.062021, - 0.188935, - -0.085646, - -0.063652, - 0.342882, - 0.252698, - 0.261036, - -0.350579, - 0.084211, - -0.446709, - -0.46899, - 0.066425, - -0.312261, - -0.157737, - 0.201989, - -0.402797, - 0.319137, - 0.340948, - 0.11782, - 0.444954, - -0.723841, - -0.143322, - -0.489569, - 0.205669, - 0.069806, - 0.134127, - 0.342895, - -0.151168, - 0.240085, - -0.084409, - 0.229139, - -0.095925, - 0.080907, - 0.58622, - -0.330253, - -0.219809, - 0.105966, - 0.272332, - 0.056774, - -0.03424, - -0.303896, - 0.06834, - -0.054558, - 0.700103, - 0.279145, - 0.094322, - -0.079162, - -0.024838, - 0.37776, - 0.248213, - 0.166896, - -0.090808, - -0.114593, - -0.261006, - 0.009821, - -0.133287, - -0.302818, - -0.154596, - 0.472001, - -0.281457, - 0.075253, - 0.119903, - -0.012666, - -0.221172, - -0.010171, - -0.221085, - -0.3849, - -0.309982, - -0.057046, - 0.091029, - -0.195692, - 0.388581, - -0.168887, - -0.305358, - -0.195026, - -0.162187, - -0.315158, - -0.029084, - 0.213467, - 0.205889, - 0.264233, - 0.176377, - 0.091347, - -0.218539, - 0.387052, - 1.217485, - 0.328843, - -0.273032, - 0.096577, - -0.385888, - 0.00428, - -0.253199, - -0.269235, - 0.147303, - 0.254599, - 0.286087, - 0.15229, - -0.379866, - -0.197259, - -0.10342, - 0.014841, - -0.109151, - 0.093473, - -0.05089, - 0.330611, - -0.2258, - -0.234845, - -0.153168, - 0.072809, - 0.145845, - 0.158106, - -0.195996, - -0.261112, - -0.547397, - 0.283834, - 0.379004, - 0.15977, - -0.244029, - 0.24982, - -0.298928, - 0.025721, - -0.278897, - -0.340025, - -0.011677, - 0.539511, - 0.549064, - -0.407466, - 0.162608, - -0.131274, - 0.184529, - 0.086208, - -0.128572, - -0.033347, - -0.211901, - -0.15657, - -0.287032, - -0.044611, - 0.406433, - 0.164659, - -0.099763, - -0.561314, - 0.091545, - -0.314852, - 0.373575, - -0.021363, - 0.063434, - 0.257256, - -0.17477, - 0.272696, - -0.198688, - 0.147474, - 0.301215, - 0.055094, - -0.190479, - -0.273911, - 0.046746, - 0.121942, - -0.225673, - 0.083825, - -0.078028, - -0.118952, - -0.114813, - -0.156655, - -0.238773, - 0.287535, - 0.574892, - -0.022095, - 0.094991, - 0.323944, - -0.165416, - 0.259925, - -0.230038, - 0.006743, - -0.1673, - 0.438739, - 0.149692, - 0.343914, - 0.255016, - -0.274129, - -0.1073, - -0.239997, - -0.074861, - -0.189394, - 0.233861, - -0.14442, - -0.681677, - 0.243212, - -0.169081, - -0.152924, - -0.32114, - -0.328237, - 0.219171, - 0.408266, - -0.138685, - 0.008192, - -0.070442, - 0.191866, - 0.159356, - 0.155582, - -0.049696, - -0.17831, - 0.163278, - -0.042806, - 0.172803, - 0.210047, - 0.096987, - -0.139165, - 0.1145, - 0.298918, - -0.222182, - -0.130973, - 0.181081, - 0.112586, - -0.07398, - -0.294592, - -0.234792, - 0.090822, - -0.573539, - 0.247071, - 0.224374, - 0.146162, - 0.513103, - -0.302966, - -0.074994, - -0.088135, - -0.045947, - 0.027147, - -0.207624, - -0.502636, - -0.048252, - -0.433258, - 0.053403, - 0.042275, - 0.14746, - 0.259323, - 0.189724, - -0.224677, - 0.451945, - -0.036209, - -0.056724, - 0.231951, - 0.113578, - 0.004858, - -0.223719, - 0.19793, - 0.252589, - 0.492237, - -0.384448, - -0.019116, - -0.115334, - 0.172316, - 0.101091, - 0.101436, - -0.095087, - 0.004483, - -0.424709, - 0.334086, - 0.134149, - -0.143216 - ] - }, - { - "concept": "ironically", - "distance": 4.1841917, - "vector": [ - -0.359413, - -0.230651, - 0.210207, - 0.231998, - -0.102257, - 0.064012, - 0.252076, - 0.005881, - 0.164502, - 0.317766, - 0.509629, - -0.023484, - -0.024773, - -0.257088, - -0.424079, - 0.521477, - 0.096174, - -0.199431, - -0.085099, - 0.168272, - 0.165731, - 0.337439, - -0.03137, - -0.009109, - -0.011882, - -0.252991, - -0.129378, - 0.273976, - -0.413546, - 0.329986, - 0.510051, - 0.229735, - 0.049416, - 0.253837, - 0.311669, - -0.477669, - 0.090821, - 0.125947, - 0.14208, - 0.250061, - -0.100138, - 0.065126, - 0.362038, - -0.281164, - 0.241468, - -0.093198, - 0.306825, - 0.325433, - -0.282219, - -0.017541, - -0.1865, - -0.159721, - 0.106631, - -0.145229, - -0.03894, - 0.0208, - -0.097091, - 0.121552, - 0.265799, - 0.118499, - 0.175325, - -0.369742, - -0.130691, - -0.176438, - 0.0494, - -0.181187, - 0.008721, - 0.16226, - -0.008068, - -0.120335, - 0.08866, - 0.240127, - 0.019587, - 0.279034, - 0.412957, - -0.376089, - -0.055204, - 0.113807, - -0.019445, - 0.119611, - -0.176299, - -0.225953, - -0.255765, - -0.176271, - 0.528281, - 0.097307, - 0.033303, - 0.477723, - -0.00174, - 0.260582, - 0.282242, - 0.244004, - -0.192828, - 0.104439, - -0.117739, - -0.117931, - -0.040824, - -0.401002, - -0.297831, - 0.35155, - -0.108224, - 0.0425, - 0.419554, - 0.147984, - -0.129344, - -0.006502, - -0.093937, - -0.572428, - -0.084652, - 0.259876, - 0.290213, - -0.231971, - 0.30126, - 0.061253, - -0.209153, - -0.333939, - -0.101162, - -0.043274, - 0.189054, - -0.086427, - -0.114987, - -0.142224, - 0.305761, - 0.310107, - 0.048216, - 0.116603, - 1.448412, - 0.292756, - -0.073426, - 0.114998, - -0.226866, - -0.188151, - -0.268786, - -0.420381, - -0.096178, - 0.460575, - 0.125989, - 0.015085, - -0.197383, - -0.043574, - 0.220412, - 0.280006, - -0.488255, - 0.01312, - -0.0572, - 0.307819, - -0.088395, - -0.175173, - -0.203317, - 0.059504, - 0.201377, - 0.290851, - -0.315372, - -0.161219, - -0.342294, - 0.444918, - 0.281892, - -0.020165, - 0.161664, - 0.252371, - -0.521235, - -0.164721, - -0.405241, - 0.142871, - -0.0508, - 0.158144, - 0.213112, - -0.407928, - 0.180893, - -0.020534, - -0.337912, - 0.155366, - -0.446614, - 0.008718, - -0.067179, - -0.178843, - -0.021474, - -0.272852, - 0.19186, - 0.411763, - -0.150666, - -0.463159, - -0.057833, - -0.27318, - 0.414181, - -0.117118, - -0.047434, - 0.389656, - 0.071299, - 0.198173, - 0.286974, - 0.068899, - 0.4411, - 0.125404, - -0.461521, - 0.201154, - -0.098209, - 0.269593, - -0.146509, - -0.125165, - -0.038811, - -0.320228, - 0.029559, - -0.26636, - -0.174484, - 0.44525, - 0.302809, - -0.253082, - -0.157891, - 0.295668, - -0.452733, - 0.578112, - -0.278543, - -0.080819, - -0.006456, - 0.421316, - 0.030774, - 0.267428, - 0.229272, - -0.289251, - 0.121442, - -0.010282, - -0.035543, - -0.294547, - -0.062076, - 0.091095, - -0.344516, - 0.056314, - -0.09577, - -0.026847, - -0.512296, - -0.273554, - 0.242927, - 0.203498, - 0.08741, - -0.000039, - 0.134626, - 0.019446, - -0.007828, - 0.309201, - 0.145901, - 0.024094, - -0.023623, - 0.092732, - 0.021162, - 0.035063, - 0.128997, - 0.145547, - -0.123454, - 0.180681, - -0.034721, - 0.143415, - 0.145334, - 0.155147, - 0.181079, - -0.19403, - -0.218318, - 0.055161, - -0.659305, - -0.16495, - 0.104386, - 0.170797, - 0.231801, - 0.074706, - 0.253907, - 0.056015, - 0.094513, - 0.360472, - -0.447779, - -0.46071, - -0.332866, - -0.213654, - 0.506279, - -0.050583, - -0.23091, - -0.251093, - -0.149163, - -0.151267, - 0.510416, - 0.27716, - 0.017702, - 0.159412, - 0.303795, - 0.099311, - -0.03409, - 0.031473, - 0.362593, - 0.356537, - -0.31941, - -0.123061, - -0.062473, - -0.081764, - 0.030498, - -0.230839, - -0.330493, - 0.047585, - 0.08363, - 0.219682, - 0.075985, - -0.264067 - ] - }, - { - "concept": "seldom", - "distance": 4.2725096, - "vector": [ - -0.202318, - -0.044683, - 0.30488, - 0.170458, - -0.138352, - -0.030951, - 0.228286, - -0.052516, - 0.323257, - 0.34478, - 0.076094, - -0.107384, - -0.21732, - -0.340282, - -0.408752, - 0.256945, - -0.261899, - -0.025887, - -0.528493, - -0.115084, - -0.306839, - 0.342076, - 0.343796, - 0.349776, - -0.15473, - -0.02448, - 0.008585, - -0.388842, - -0.492813, - 0.334493, - 0.564697, - -0.110175, - 0.27117, - 0.469717, - 0.283594, - -0.132994, - 0.376772, - -0.056062, - -0.105669, - 0.529899, - -0.026018, - -0.144774, - 0.406046, - -0.197428, - 0.138098, - 0.111642, - 0.20106, - -0.022793, - -0.438669, - -0.288734, - -0.20097, - -0.093903, - 0.040041, - 0.009455, - -0.461317, - 0.36562, - -0.172973, - 0.021527, - 0.209511, - 0.105467, - 0.369181, - -0.529023, - -0.445617, - -0.527424, - 0.225753, - -0.368249, - -0.257268, - 0.085983, - -0.160534, - -0.086302, - -0.079141, - 0.149935, - -0.303261, - -0.1067, - 0.330265, - -0.445073, - 0.028517, - 0.290381, - -0.079916, - -0.223362, - 0.190159, - -0.692779, - 0.383965, - 0.283159, - 0.082878, - 0.143011, - 0.168409, - 0.383986, - -0.118241, - 0.261873, - 0.392375, - -0.06502, - -0.26937, - -0.513962, - 0.197601, - 0.122183, - -0.360326, - -0.4502, - 0.360568, - 0.24289, - -0.232527, - -0.369868, - 0.563784, - 0.123422, - -0.522635, - -0.10998, - -0.551091, - -0.392757, - -0.056108, - 0.046478, - 0.002478, - -0.247894, - 0.255811, - -0.093877, - -0.220728, - -0.119953, - 0.12152, - -0.208762, - -0.060245, - -0.068988, - -0.105826, - -0.03618, - 0.040023, - 0.12975, - -0.210964, - 0.098034, - 1.220443, - 0.242402, - -0.3855, - -0.021119, - -0.18248, - 0.04337, - -0.5891, - -0.476421, - -0.040971, - 0.661542, - 0.577477, - -0.142126, - -0.175651, - -0.186789, - 0.139635, - -0.168742, - -0.188041, - -0.120634, - 0.211768, - 0.301022, - -0.113122, - -0.188238, - -0.098644, - 0.140813, - -0.168418, - 0.218009, - -0.329449, - -0.187928, - -0.540164, - 0.433922, - -0.22486, - 0.028824, - 0.015588, - -0.053625, - -0.21321, - -0.196971, - -0.43029, - 0.039156, - -0.317983, - 0.138702, - 0.586319, - -0.305632, - -0.001035, - -0.227148, - -0.310764, - 0.144544, - -0.25522, - -0.167605, - -0.115899, - -0.472049, - -0.344132, - -0.163742, - -0.016814, - 0.038108, - 0.127277, - -0.471746, - -0.300755, - 0.048182, - 0.526615, - 0.164655, - 0.200431, - 0.010462, - 0.152977, - 0.028094, - -0.418348, - 0.152106, - 0.266668, - -0.021742, - -0.052987, - 0.175744, - -0.067273, - 0.212729, - -0.206729, - 0.418981, - 0.064973, - 0.093121, - -0.068022, - -0.193373, - 0.167144, - 0.43016, - 0.372979, - 0.002964, - -0.020553, - 0.125149, - -0.054637, - 0.262491, - -0.298696, - 0.054127, - 0.052454, - 0.106873, - 0.101087, - 0.217352, - 0.399422, - -0.485308, - -0.195191, - -0.236138, - 0.15575, - -0.345084, - -0.053425, - 0.090949, - -0.500235, - -0.039471, - 0.26852, - -0.353873, - -0.334935, - -0.58248, - -0.004243, - 0.07444, - 0.2969, - -0.211977, - -0.069635, - 0.107885, - 0.002363, - -0.070619, - 0.073015, - -0.12956, - -0.188925, - 0.166967, - 0.358604, - 0.047415, - -0.225666, - -0.157507, - 0.027925, - 0.028972, - -0.36403, - 0.018574, - -0.088511, - 0.297059, - 0.031074, - -0.466482, - 0.028567, - 0.200242, - -0.319626, - 0.080205, - 0.374648, - 0.248535, - 0.180631, - -0.169957, - 0.082377, - 0.049386, - 0.01929, - -0.10656, - -0.163778, - -0.468327, - 0.051826, - -0.135131, - 0.182269, - -0.000333, - -0.230123, - 0.10039, - 0.17738, - -0.008471, - 0.615003, - 0.048243, - 0.087662, - -0.163326, - 0.24246, - 0.102032, - -0.063598, - -0.030202, - 0.361225, - 0.487855, - -0.333984, - 0.120478, - 0.040364, - -0.186075, - -0.329071, - -0.078048, - -0.40894, - -0.243726, - -0.245414, - 0.18134, - 0.117596, - 0.12896 - ] - }, - { - "concept": "unaware", - "distance": 4.2726655, - "vector": [ - -0.348543, - -0.175642, - 0.085672, - 0.043555, - -0.16213, - 0.261347, - -0.016919, - 0.005579, - 0.043558, - 0.198459, - 0.290774, - 0.22924, - -0.224189, - -0.0606, - -0.268839, - 0.013864, - 0.07728, - -0.316176, - -0.245814, - -0.269814, - 0.133969, - 0.720785, - 0.115849, - 0.157891, - -0.122512, - -0.196943, - 0.046596, - 0.223739, - -0.586074, - -0.001449, - 0.222566, - 0.292443, - 0.369355, - 0.417842, - 0.325231, - -0.482941, - -0.037572, - -0.187681, - 0.062631, - 0.523298, - -0.189101, - -0.086207, - 0.170493, - -0.213692, - 0.053728, - -0.162246, - -0.054887, - 0.317032, - -0.818662, - 0.068203, - -0.28184, - -0.1642, - 0.057501, - 0.009685, - -0.234967, - -0.148069, - -0.045034, - 0.083057, - 0.338357, - 0.008678, - -0.004057, - -0.318977, - 0.206766, - -0.390611, - 0.51508, - 0.052052, - 0.028128, - 0.146617, - -0.324637, - 0.047365, - 0.263266, - 0.539739, - -0.659754, - 0.167783, - 0.344293, - -0.012115, - -0.05572, - 0.104154, - -0.092781, - 0.113328, - -0.305673, - -0.208341, - 0.094392, - 0.026365, - 0.616002, - -0.072317, - -0.021079, - 0.016302, - 0.056057, - 0.198542, - 0.160294, - 0.037677, - -0.135843, - 0.127124, - -0.096455, - -0.043607, - -0.454571, - -0.328412, - -0.283509, - 0.320155, - 0.135541, - -0.593568, - 0.295892, - -0.052379, - -0.264129, - 0.176556, - -0.193814, - -0.415773, - -0.12079, - 0.350459, - 0.348922, - -0.294373, - 0.074845, - -0.006813, - -0.169338, - -0.491111, - 0.054501, - 0.081183, - -0.220489, - 0.012321, - -0.162682, - -0.07668, - 0.276311, - -0.040467, - 0.246905, - 0.260439, - 1.61841, - 0.021811, - 0.174857, - -0.042737, - -0.141755, - -0.014151, - -0.146945, - -0.5539, - -0.092645, - 0.443033, - 0.450471, - 0.185342, - 0.105696, - 0.019375, - 0.280532, - 0.00527, - -0.413165, - -0.114871, - 0.14245, - 0.428044, - -0.367331, - -0.002574, - 0.082205, - 0.161182, - 0.037604, - -0.057688, - -0.228111, - 0.07675, - -0.317571, - 0.35727, - -0.013201, - 0.234876, - 0.145357, - 0.112789, - -0.522939, - -0.01311, - -0.434294, - -0.162413, - -0.01963, - 0.067242, - 0.291154, - -0.450556, - 0.099919, - -0.230357, - 0.049956, - -0.335509, - -0.099263, - -0.079861, - -0.157712, - -0.57849, - -0.213584, - 0.132333, - 0.011642, - 0.502463, - -0.017435, - -0.411119, - 0.13101, - -0.146916, - 0.374868, - -0.176403, - -0.019686, - 0.346069, - -0.050353, - 0.204431, - 0.086713, - 0.348427, - 0.351251, - -0.007894, - -0.161812, - 0.032048, - 0.344168, - 0.313034, - -0.265577, - 0.0457, - -0.056004, - 0.155575, - 0.31227, - 0.033565, - -0.498501, - 0.036929, - 0.466963, - -0.328437, - 0.035022, - -0.05875, - -0.260136, - 0.269718, - -0.001386, - 0.155674, - 0.0896, - 0.256544, - -0.208402, - 0.016586, - 0.216751, - -0.409504, - 0.297094, - -0.021355, - 0.178101, - -0.522663, - -0.344005, - 0.204074, - -0.089203, - 0.197277, - -0.036556, - -0.402342, - -0.442255, - -0.430027, - 0.267445, - 0.046627, - 0.164023, - -0.090807, - 0.101913, - 0.042609, - 0.380415, - 0.36765, - 0.376404, - -0.050133, - -0.020096, - 0.243357, - 0.279124, - -0.09481, - -0.362422, - -0.172856, - -0.054756, - 0.124423, - 0.210206, - 0.225775, - -0.175352, - 0.126249, - 0.309763, - -0.544837, - -0.042834, - 0.145738, - -0.451459, - -0.052258, - 0.257358, - -0.081731, - 0.414317, - -0.007436, - 0.194527, - 0.160306, - -0.122656, - -0.019364, - -0.429529, - -0.4479, - -0.107885, - -0.522249, - 0.158996, - -0.228632, - -0.024366, - -0.004828, - -0.266969, - -0.522236, - 0.471044, - 0.412422, - 0.203436, - -0.117237, - 0.363039, - 0.031489, - -0.082099, - 0.079138, - 0.384403, - 0.273576, - -0.335693, - -0.004829, - -0.133937, - 0.053371, - 0.145258, - 0.064068, - -0.259939, - -0.118813, - 0.008409, - 0.129281, - 0.483926, - 0.200778 - ] - }, - { - "concept": "suffice", - "distance": 4.2861743, - "vector": [ - -0.483434, - -0.230426, - 0.242913, - 0.082559, - -0.005102, - -0.294073, - 0.048379, - -0.015992, - 0.013523, - 0.516144, - 0.258777, - 0.290465, - -0.276965, - -0.42632, - -0.173937, - 0.04608, - 0.022312, - -0.064423, - -0.356078, - -0.069854, - 0.137882, - 0.259331, - 0.008831, - 0.049828, - 0.002255, - 0.010864, - -0.092922, - 0.060522, - -0.550784, - 0.061464, - 0.218556, - 0.023415, - 0.302413, - 0.173822, - 0.367932, - -0.036734, - -0.058327, - 0.053726, - -0.120286, - 0.613205, - -0.358737, - 0.007838, - 0.172902, - -0.100142, - -0.045194, - 0.086093, - 0.182583, - -0.054688, - -0.167408, - -0.215105, - -0.295163, - -0.059449, - 0.005058, - -0.326463, - 0.05372, - 0.224693, - -0.00213, - 0.121332, - 0.565872, - 0.065493, - 0.227838, - -0.504976, - -0.407809, - -0.423915, - 0.418528, - 0.000684, - -0.312981, - -0.067377, - -0.082965, - -0.004447, - -0.174183, - 0.28256, - -0.36163, - 0.210812, - 0.415138, - -0.75285, - -0.16197, - 0.449196, - 0.156854, - -0.060502, - -0.222954, - -0.616159, - 0.048419, - 0.15656, - 0.537671, - 0.242085, - -0.026323, - 0.059541, - -0.139125, - 0.303788, - 0.486624, - 0.195507, - -0.0715, - -0.252686, - -0.101754, - 0.059021, - -0.045593, - -0.587323, - 0.540681, - 0.222123, - -0.387939, - -0.144159, - 0.332595, - 0.25475, - -0.53241, - -0.08911, - -0.229781, - -0.423731, - -0.202414, - -0.330824, - 0.22389, - -0.046261, - 0.411086, - -0.225788, - -0.363607, - -0.209196, - -0.278213, - -0.627382, - -0.189394, - 0.170575, - -0.108699, - 0.075093, - 0.205757, - -0.173231, - -0.147694, - 0.23108, - 0.879033, - 0.154176, - -0.11269, - 0.101159, - 0.194449, - -0.117853, - -0.325819, - -0.247439, - -0.15941, - 0.377829, - 0.469849, - -0.331878, - -0.081433, - -0.059813, - 0.023066, - -0.192239, - -0.14901, - -0.299314, - -0.138673, - 0.211568, - -0.251483, - 0.152833, - -0.052704, - -0.148031, - 0.123439, - 0.055765, - -0.302812, - 0.208079, - -0.372613, - 0.208382, - 0.116523, - 0.051424, - -0.183738, - 0.027591, - -0.39855, - 0.087566, - -0.372247, - -0.013887, - 0.118843, - 0.340075, - 0.274275, - -0.060341, - 0.106218, - -0.004055, - -0.097183, - -0.187265, - 0.037396, - 0.259477, - -0.315955, - -0.255566, - -0.22567, - -0.219471, - 0.119693, - 0.046583, - -0.189576, - -0.467983, - -0.141509, - -0.154731, - 0.46154, - 0.391969, - 0.025587, - 0.106998, - -0.013758, - 0.024941, - -0.20418, - 0.062886, - 0.189113, - -0.238911, - -0.025872, - 0.022088, - -0.104022, - 0.17474, - -0.44483, - -0.00254, - -0.480345, - 0.011864, - 0.014851, - 0.204317, - 0.190274, - 0.269999, - 0.153028, - -0.394214, - 0.102886, - 0.249666, - -0.149616, - 0.220635, - 0.13809, - 0.13184, - -0.163973, - 0.016585, - 0.019579, - 0.127986, - 0.006825, - -0.349072, - -0.139446, - 0.167125, - -0.201182, - -0.294854, - -0.062354, - -0.38458, - -0.543579, - -0.143713, - -0.088344, - -0.14373, - -0.177182, - -0.659199, - 0.059349, - 0.056051, - -0.27632, - -0.060422, - -0.077852, - 0.093678, - 0.204402, - 0.132878, - 0.146321, - -0.02086, - -0.131694, - -0.058714, - -0.133472, - 0.537992, - -0.234797, - 0.161369, - 0.179826, - 0.026062, - -0.188758, - 0.063846, - 0.368611, - -0.105519, - -0.168184, - -0.339118, - -0.142704, - -0.099193, - -0.462293, - 0.1414, - -0.059704, - 0.131869, - 0.213537, - -0.293336, - -0.104343, - -0.079413, - 0.020884, - -0.008099, - 0.083703, - -0.253668, - -0.257465, - -0.227151, - -0.01286, - -0.180092, - -0.184429, - 0.061758, - -0.016782, - -0.303048, - 0.182242, - 0.217731, - -0.226228, - -0.274921, - 0.267964, - 0.010922, - 0.052102, - 0.452248, - -0.017188, - 0.712053, - -0.125325, - 0.013379, - 0.254341, - -0.047431, - -0.225847, - 0.068985, - -0.201531, - -0.069251, - -0.116094, - 0.261999, - 0.260615, - 0.002746 - ] - }, - { - "concept": "surprisingly", - "distance": 4.302674, - "vector": [ - -0.464285, - 0.391226, - -0.046054, - -0.210413, - 0.145662, - 0.052989, - 0.126804, - -0.049955, - 0.265239, - 0.090281, - 0.128958, - 0.142857, - -0.267439, - -0.001014, - 0.174036, - 0.500274, - 0.011775, - -0.09268, - -0.190118, - 0.034292, - -0.121491, - 0.170478, - -0.35023, - -0.014654, - -0.025781, - -0.033122, - 0.132231, - -0.129456, - -0.474397, - 0.052545, - -0.117416, - -0.173633, - 0.178137, - 0.317986, - 0.124731, - -0.493883, - -0.427795, - -0.076979, - -0.492946, - 0.064582, - 0.246126, - 0.033825, - 0.027075, - -0.254685, - -0.388823, - 0.101625, - 0.07573, - 0.236028, - 0.088133, - -0.166501, - 0.082046, - -0.076056, - -0.435752, - -0.099232, - -0.065763, - 0.132749, - 0.229515, - -0.129289, - -0.299901, - 0.045257, - -0.174129, - -0.259751, - -0.104153, - -0.199945, - 0.476253, - -0.088358, - -0.132278, - -0.314732, - 0.003225, - 0.028707, - -0.074578, - -0.196132, - 0.039901, - -0.148555, - 0.246047, - -0.255187, - -0.062554, - 0.234466, - -0.073907, - 0.119187, - 0.144792, - 0.042137, - 0.020774, - 0.082529, - 0.03356, - -0.110879, - 0.001071, - -0.129199, - 0.142066, - 0.081966, - 0.234349, - -0.185881, - -0.00855, - 0.010763, - -0.188533, - 0.189433, - -0.16748, - -0.376197, - 0.155857, - -0.165777, - -0.187758, - -0.118083, - 0.117618, - -0.070495, - -0.161442, - -0.171125, - 0.143802, - -0.10731, - -0.007857, - -0.153587, - 0.091644, - 0.276246, - -0.015062, - 0.259103, - 0.087038, - -0.232847, - 0.175199, - -0.125654, - -0.547671, - -0.020359, - 0.036493, - -0.005948, - 0.111927, - 0.003291, - 0.039979, - -0.171594, - 0.373054, - -0.09361, - -0.100097, - 0.166335, - 0.112134, - -0.03, - 0.061502, - -0.093385, - 0.109211, - 0.183266, - -0.156485, - 0.114118, - 0.115013, - 0.317851, - -0.143371, - -0.249172, - -0.280985, - 0.132271, - -0.00467, - 0.413185, - -0.299864, - 0.097791, - 0.091075, - 0.11769, - -0.032696, - 0.178657, - -0.158961, - 0.0625, - 0.074004, - 0.287279, - -0.294218, - 0.069898, - -0.354989, - -0.092576, - 0.133313, - -0.340195, - -0.270688, - -0.104402, - -0.191763, - 0.246809, - 0.155414, - -0.285687, - 0.084942, - -0.135485, - -0.192644, - 0.261127, - 0.117475, - -0.040463, - -0.076809, - -0.217945, - 0.055813, - -0.120669, - 0.115473, - 0.076795, - -0.251186, - -0.361054, - -0.114556, - -0.095885, - 0.086618, - -0.220575, - -0.102849, - 0.255775, - -0.073521, - -0.194078, - 0.267029, - 0.099535, - 0.129477, - 0.029396, - -0.010335, - 0.174574, - 0.206237, - 0.143854, - 0.264891, - -0.069791, - -0.101537, - -0.405468, - 0.136908, - 0.057074, - -0.28413, - 0.193714, - -0.004922, - 0.252293, - -0.018675, - 0.00143, - -0.174588, - -0.070175, - -0.128861, - 0.332791, - -0.137015, - 0.271298, - 0.094554, - 0.261649, - -0.089425, - -0.150892, - 0.014027, - 0.18274, - 0.346178, - -0.081623, - -0.218073, - 0.057098, - -0.614693, - -0.177543, - -0.106611, - -0.188715, - -0.182236, - -0.048218, - 0.141081, - -0.038297, - -0.047993, - -0.117997, - 0.083073, - 0.471196, - -0.285103, - -0.176019, - 0.130298, - -0.032258, - 0.051792, - 0.092051, - 0.397442, - 0.184724, - -0.303761, - 0.384567, - -0.266187, - -0.126972, - 0.087689, - 0.100205, - 0.142916, - 0.23401, - -0.15654, - -0.34354, - -0.104486, - 0.262933, - -0.257677, - -0.306945, - 0.195409, - 0.0441, - 0.006655, - -0.156961, - -0.056621, - -0.079714, - 0.075041, - 0.153605, - -0.068442, - -0.139346, - -0.040573, - 0.223823, - 0.607355, - -0.201674, - -0.121812, - -0.187113, - -0.137898, - -0.092015, - 0.047845, - 0.371954, - -0.16993, - -0.187211, - -0.223921, - -0.013121, - 0.181104, - 0.328852, - 0.160868, - 0.298261, - -0.228216, - 0.352583, - 0.011887, - -0.014445, - -0.054325, - 0.063514, - -0.005185, - -0.199734, - 0.205993, - 0.03763, - -0.036142, - 0.056167 - ] - }, - { - "concept": "encountered", - "distance": 4.34014, - "vector": [ - -0.273572, - -0.164246, - 0.273927, - 0.163631, - -0.084287, - -0.055738, - -0.019035, - -0.016163, - 0.380239, - 0.44997, - 0.32953, - -0.059854, - 0.061891, - -0.128593, - -0.160989, - 0.395338, - 0.169944, - -0.026135, - -0.552229, - -0.426699, - 0.050256, - 0.427517, - -0.066433, - 0.444512, - -0.300352, - -0.278216, - -0.086381, - 0.176446, - -0.515921, - 0.204234, - 0.276126, - 0.069466, - 0.19499, - 0.220915, - 0.236658, - -0.246308, - 0.155909, - 0.178598, - -0.126379, - 0.410443, - -0.145286, - 0.064101, - 0.139411, - -0.173602, - -0.098265, - 0.34711, - 0.285407, - 0.517346, - -0.35212, - 0.032122, - 0.008932, - -0.030616, - -0.095124, - 0.074985, - -0.214858, - 0.218093, - 0.153213, - 0.049386, - 0.057423, - 0.051054, - 0.401565, - -0.441978, - -0.14682, - -0.090513, - 0.232106, - 0.079808, - -0.6384, - 0.041019, - -0.014309, - -0.403252, - -0.263763, - 0.236091, - 0.108376, - 0.219151, - 0.323345, - -0.702189, - -0.012796, - 0.218182, - -0.090618, - 0.174708, - -0.01067, - -0.427208, - 0.376252, - -0.213776, - 0.429865, - 0.294736, - -0.055363, - 0.370317, - -0.284937, - 0.460189, - 0.167469, - 0.388887, - -0.048486, - -0.095668, - 0.053125, - 0.32164, - -0.169671, - -0.496072, - -0.052366, - 0.213124, - -0.36319, - -0.057114, - 0.599438, - 0.32305, - -0.103934, - -0.108926, - -0.3538, - -0.555613, - -0.160199, - 0.06474, - 0.218676, - 0.185149, - 0.682627, - 0.03229, - 0.035072, - -0.486507, - 0.171353, - -0.328085, - 0.180237, - -0.020516, - -0.186651, - 0.299314, - -0.024001, - 0.413593, - -0.013381, - 0.473236, - 1.659078, - 0.767726, - -0.12184, - -0.010089, - 0.099828, - -0.159074, - -0.643264, - -0.558826, - -0.490348, - 0.172573, - 0.42942, - -0.173793, - -0.187355, - -0.220383, - -0.191416, - 0.004565, - -0.649196, - -0.337409, - 0.070548, - 0.334084, - -0.328519, - 0.183457, - -0.305898, - 0.379839, - 0.148708, - 0.406879, - -0.493676, - -0.257871, - -0.089992, - 0.199068, - 0.174448, - 0.222593, - -0.15612, - -0.078995, - -0.053881, - -0.261365, - -0.464628, - 0.012612, - -0.2595, - 0.037643, - 0.410269, - -0.039175, - 0.261967, - -0.418862, - -0.177408, - 0.198179, - -0.108887, - 0.025931, - -0.465068, - -0.40547, - 0.282417, - -0.287103, - -0.072068, - -0.054911, - -0.45903, - -0.777791, - -0.199091, - -0.111358, - 0.578856, - 0.123428, - 0.044039, - -0.017987, - 0.070673, - 0.24311, - 0.204894, - 0.022624, - 0.126848, - 0.174975, - -0.113673, - 0.160165, - -0.242296, - 0.176144, - -0.11426, - -0.033214, - 0.193405, - -0.170739, - 0.1506, - -0.447328, - -0.386691, - 0.793782, - 0.272841, - -0.126025, - 0.033455, - 0.075467, - 0.000774, - 0.068487, - -0.454372, - 0.119548, - 0.085799, - 0.009984, - 0.207329, - 0.130531, - -0.310732, - 0.016461, - 0.016456, - 0.142762, - 0.015945, - -0.351269, - 0.016501, - -0.020624, - -0.490789, - -0.0837, - 0.28578, - -0.179368, - -0.681045, - -0.496967, - 0.250285, - 0.170171, - 0.077386, - 0.087733, - 0.192022, - -0.042838, - 0.086946, - 0.310586, - 0.192405, - -0.016577, - 0.368751, - 0.195543, - -0.030193, - -0.127536, - -0.091653, - -0.095472, - 0.057039, - -0.285372, - -0.075996, - 0.446501, - 0.28684, - -0.011063, - 0.598943, - -0.308274, - -0.072809, - 0.117701, - -0.481397, - 0.11186, - 0.149582, - -0.033432, - 0.094432, - -0.241915, - 0.05566, - -0.083037, - 0.293524, - -0.005516, - -0.267004, - -0.253745, - -0.461152, - -0.083826, - 0.46625, - -0.076947, - -0.136923, - -0.354863, - -0.144027, - -0.040518, - 0.260751, - 0.780067, - -0.016757, - -0.074571, - 0.259961, - 0.043093, - 0.189784, - 0.094731, - 0.210817, - 0.467035, - -0.108643, - 0.31309, - 0.293574, - 0.432059, - 0.111474, - -0.217014, - -0.475247, - 0.28318, - -0.069709, - -0.156828, - 0.111476, - -0.263285 - ] - } - ] - } - }, - "class": "Soup", - "creationTimeUnix": 1617830598531, - "id": "565da3b6-60b3-40e5-ba21-e6bfe5dbba91", - "lastUpdateTimeUnix": 1617830598531, - "properties": { - "description": "Used by humans when their inferior genetics are attacked by microscopic organisms.", - "name": "ChickenSoup" - }, - "vector": [ - 0.016080264, - -0.034203023, - -0.17354329, - -0.07175126, - 0.20285407, - -0.19775264, - -0.16492559, - 0.031864163, - -0.2880885, - 0.33725733, - 0.10932778, - 0.050714564, - 0.06653664, - 0.37414858, - -0.15166822, - 0.018445412, - -0.21244912, - 0.029528495, - -0.38339266, - -0.07206091, - 0.011346168, - 0.31128982, - 0.16965142, - 0.047169067, - -0.36166123, - -0.32068834, - -0.07790354, - -0.2784608, - -0.09716653, - 0.09333659, - 0.16637348, - -0.15559089, - 0.5603675, - 0.062324464, - -0.030909093, - -0.09440621, - 0.29645526, - 0.03890725, - -0.06897718, - 0.042938296, - -0.21405445, - 0.03227006, - -0.076473005, - -0.030370224, - 0.043327134, - 0.3219818, - -0.03753003, - 0.13365442, - -0.17192307, - -0.08977324, - 0.13660595, - -0.00007706349, - -0.022967221, - -0.22840862, - -0.06024632, - -0.06502664, - 0.10706806, - -0.11362547, - 0.16879557, - 0.09096705, - 0.5043584, - -0.4536421, - -0.21936159, - -0.07344543, - 0.09572999, - -0.029478686, - -0.051548246, - -0.010593718, - -0.04109537, - 0.1747486, - 0.02075262, - 0.080171585, - -0.34439775, - 0.29307353, - 0.13172597, - -0.39632678, - 0.075215705, - 0.22274326, - 0.10186249, - -0.11137561, - 0.043386374, - -0.14526981, - 0.20097081, - -0.06299718, - 0.120754935, - -0.08312063, - 0.32485947, - -0.070942886, - -0.015228356, - 0.17497778, - 0.17159964, - 0.22385485, - -0.049656495, - -0.015198379, - -0.08535228, - 0.17166519, - -0.12031916, - -0.20646523, - -0.22601576, - 0.2845237, - -0.14149246, - -0.4123429, - 0.18702444, - 0.16531585, - -0.13993144, - -0.031872265, - 0.055056456, - -0.3581531, - -0.32072335, - 0.08455001, - -0.015341981, - -0.029472869, - 0.020745233, - 0.13800298, - -0.12638605, - -0.34710097, - 0.30824816, - -0.3520461, - -0.11748648, - 0.057904646, - -0.27266228, - 0.11925154, - 0.062467407, - -0.0034145922, - 0.30924985, - 0.2161129, - 1.3445412, - 0.20663446, - -0.49156317, - 0.37960225, - -0.30191928, - -0.18578006, - -0.30675077, - -0.29710016, - -0.08381206, - 0.49570912, - -0.096599266, - 0.2858525, - -0.29623547, - -0.3334595, - -0.04835808, - -0.08452747, - -0.29691428, - -0.40554157, - 0.34801576, - 0.15767589, - -0.08402861, - 0.21176746, - 0.303947, - -0.1944298, - 0.104637705, - 0.09550315, - -0.10478378, - 0.14382702, - 0.020624492, - 0.33446243, - -0.17376803, - 0.110565044, - -0.046801522, - -0.1149258, - -0.17781256, - -0.13892059, - -0.039319307, - -0.035836793, - -0.15973847, - 0.27109683, - 0.36579052, - -0.1823787, - 0.011673369, - -0.21660313, - -0.1344544, - 0.06613864, - 0.09713564, - 0.097363465, - -0.14026, - -0.21439382, - -0.22019295, - -0.010595505, - -0.06623841, - 0.029797047, - -0.49004197, - -0.579102, - 0.06913833, - -0.27524185, - 0.21526997, - 0.24281693, - 0.28751627, - 0.32884803, - 0.11384182, - -0.024324464, - 0.28246126, - 0.2900123, - -0.20781049, - 0.27757952, - 0.21086226, - -0.115587376, - 0.09703406, - 0.15407756, - -0.24807887, - -0.12418233, - 0.031640753, - -0.047838982, - 0.23322861, - 0.02131002, - -0.07699835, - 0.23109762, - 0.23280933, - -0.040164266, - -0.07456687, - 0.11898091, - -0.14825699, - 0.07796567, - -0.16697076, - 0.20492445, - -0.114271194, - 0.13633233, - 0.2933071, - 0.16719492, - -0.13598129, - -0.071527556, - 0.19937927, - -0.056370806, - 0.2838016, - -0.19001369, - 0.23278204, - 0.11358514, - -0.47129726, - -0.0000025950715, - -0.23180819, - -0.30457982, - -0.38032693, - -0.34985495, - -0.00008929884, - 0.20415005, - 0.012986345, - 0.0103855925, - 0.02956246, - 0.41342616, - -0.044166096, - -0.060423322, - 0.27983725, - -0.047862083, - 0.34985617, - 0.04874184, - -0.21438845, - -0.19891484, - 0.31520727, - 0.0043795095, - -0.14582366, - 0.049720645, - -0.045054518, - -0.039748516, - 0.19673592, - 0.1269421, - 0.13347843, - -0.23943658, - -0.108751774, - 0.16037288, - -0.15055116, - 0.048193913, - 0.13487507, - 0.064719334, - -0.121152416, - -0.12565044, - 0.042851467, - -0.11500127, - -0.122011386, - -0.037173934, - -0.23786242, - -0.40830806, - -0.017876096, - -0.18151718, - -0.11087986, - -0.20682277, - 0.10457005, - 0.09406542, - -0.16536163, - -0.0831362, - 0.24354741, - 0.1812581, - 0.34306931, - 0.004188206, - 0.36012915, - 0.20446225, - 0.12302716, - -0.1811172, - 0.29436284, - 0.11813032, - -0.031875905, - 0.21684766, - -0.26503322, - 0.013936491, - -0.15311196, - 0.08996625, - -0.279231, - 0.13769647, - -0.19230065, - 0.22818297, - 0.40020758, - -0.1894623 - ], - "vectorWeights": null -} \ No newline at end of file diff --git a/src/test/resources/json/object2.json b/src/test/resources/json/object2.json deleted file mode 100644 index 6d764b482..000000000 --- a/src/test/resources/json/object2.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "class": "Soup", - "creationTimeUnix": 1617889812387, - "id": "07473b34-0ab2-4120-882d-303d9e13f7af", - "properties": { - "description": "Putting the game of letter soups to a whole new level.", - "name": "Beautiful", - "otherFoods": [ - { - "beacon": "weaviate://localhost/97fa5147-bdad-4d74-9a81-f8babc811b09", - "href": "/v1/objects/97fa5147-bdad-4d74-9a81-f8babc811b09" - }, - { - "beacon": "weaviate://localhost/07473b34-0ab2-4120-882d-303d9e13f7af", - "href": "/v1/objects/07473b34-0ab2-4120-882d-303d9e13f7af" - } - ] - }, - "vectorWeights": null -} \ No newline at end of file diff --git a/src/test/resources/json/objects-list-response.json b/src/test/resources/json/objects-list-response.json deleted file mode 100644 index ff9474351..000000000 --- a/src/test/resources/json/objects-list-response.json +++ /dev/null @@ -1,50 +0,0 @@ -{ - "deprecations": null, - "objects": [ - { - "class": "Pizza", - "creationTimeUnix": 1617828214945, - "id": "302ae446-435c-471e-a434-f84bfb10b2b0", - "lastUpdateTimeUnix": 1617828214945, - "properties": { - "description": "meat", - "name": "Pepperoni" - }, - "vectorWeights": null - }, - { - "class": "Pizza", - "creationTimeUnix": 1617828214916, - "id": "5314ade4-61b6-48a8-b4b9-a89310693a63", - "lastUpdateTimeUnix": 1617828214916, - "properties": { - "description": "plain", - "name": "Margherita" - }, - "vectorWeights": null - }, - { - "class": "Soup", - "creationTimeUnix": 1617828215003, - "id": "2b6de69f-4eb7-45df-8a0a-2bb951bb0d0e", - "lastUpdateTimeUnix": 1617828215003, - "properties": { - "description": "vegetarian", - "name": "Tofu" - }, - "vectorWeights": null - }, - { - "class": "Soup", - "creationTimeUnix": 1617828214974, - "id": "7f2d3d76-1a74-4563-bd4e-18f5f50facdf", - "lastUpdateTimeUnix": 1617828214974, - "properties": { - "description": "plain", - "name": "Chicken" - }, - "vectorWeights": null - } - ], - "totalResults": 4 -} \ No newline at end of file diff --git a/tools/prepare_release.sh b/tools/prepare_release.sh index 4e071245b..09f8939a9 100755 --- a/tools/prepare_release.sh +++ b/tools/prepare_release.sh @@ -23,8 +23,8 @@ if git rev-parse "$VERSION" >/dev/null 2>&1; then fi next_version="" -if [[ "$VERSION" =~ "alpha" ]]; then - next_version=$(echo "$VERSION" | sed 's/-.*//') +if [[ "$VERSION" =~ -(alpha|beta|M|RC)[0-9]*$ ]]; then + next_version="${VERSION%%-*}" fi mvn versions:set -DnewVersion=$VERSION versions:commit